From 769ccd45758c4f92547264d33a0758d5f57b181a Mon Sep 17 00:00:00 2001 From: fpezzinosn Date: Wed, 4 May 2022 10:34:34 -0400 Subject: [PATCH 1/2] message stubs [OTA-134] --- c/include/libsbp/cpp/message_traits.h | 523 +++++++ c/include/libsbp/integrity.h | 30 + c/include/libsbp/integrity_macros.h | 165 +++ c/include/libsbp/legacy/cpp/message_traits.h | 89 +- c/include/libsbp/legacy/integrity.h | 61 + c/include/libsbp/legacy/navigation.h | 15 + c/include/libsbp/legacy/ssr.h | 38 +- c/include/libsbp/navigation_macros.h | 46 + c/include/libsbp/sbp_msg_type.h | 16 + c/include/libsbp/ssr_macros.h | 161 +- c/include/libsbp/v4/integrity.h | 27 + .../v4/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h | 184 +++ .../integrity/MSG_SSR_FLAG_IONO_GRID_POINTS.h | 187 +++ .../MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS.h | 195 +++ .../MSG_SSR_FLAG_IONO_TILE_SAT_LOS.h | 188 +++ .../v4/integrity/MSG_SSR_FLAG_SATELLITES.h | 184 +++ .../MSG_SSR_FLAG_TROPO_GRID_POINTS.h | 188 +++ c/include/libsbp/v4/navigation.h | 2 + .../v4/navigation/MSG_GPS_LEAP_SECOND.h | 188 +++ c/include/libsbp/v4/navigation/MSG_ITRF.h | 178 +++ c/include/libsbp/v4/sbp_msg.h | 179 +++ c/include/libsbp/v4/ssr.h | 6 + .../v4/ssr/MSG_SSR_CODE_PHASE_BIASES_BOUNDS.h | 194 +++ .../ssr/MSG_SSR_GRIDDED_CORRECTION_BOUNDS.h | 194 +++ .../v4/ssr/MSG_SSR_ORBIT_CLOCK_BOUNDS.h | 186 +++ .../MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION.h | 196 +++ .../libsbp/v4/ssr/MSG_SSR_STEC_CORRECTION.h | 33 +- .../v4/ssr/MSG_SSR_STEC_CORRECTION_DEP.h | 206 +++ .../libsbp/v4/ssr/MSG_SSR_TILE_DEFINITION.h | 91 +- .../v4/ssr/MSG_SSR_TILE_DEFINITION_DEP.h | 266 ++++ c/include/libsbp/version.h | 3 + c/src/include/libsbp/internal/v4/integrity.h | 156 ++ c/src/include/libsbp/internal/v4/navigation.h | 39 + c/src/include/libsbp/internal/v4/ssr.h | 121 ++ c/src/v4/integrity.c | 509 +++++++ c/src/v4/navigation.c | 155 ++ c/src/v4/ssr.c | 562 ++++++- ..._check_sbp_integrity_MsgSsrFlagHighLevel.c | 359 +++++ ..._integrity_MsgSsrFlagIonoGridPointSatLos.c | 299 ++++ ...k_sbp_integrity_MsgSsrFlagIonoGridPoints.c | 299 ++++ ...k_sbp_integrity_MsgSsrFlagIonoTileSatLos.c | 285 ++++ ...check_sbp_integrity_MsgSsrFlagSatellites.c | 246 ++++ ..._sbp_integrity_MsgSsrFlagTropoGridPoints.c | 299 ++++ ...to_check_sbp_navigation_MsgGPSLeapSecond.c | 232 +++ c/test/auto_check_sbp_navigation_MsgItrf.c | 897 ++++++++++++ ...heck_sbp_ssr_MsgSsrCodePhaseBiasesBounds.c | 369 +++++ ...ck_sbp_ssr_MsgSsrGriddedCorrectionBounds.c | 454 ++++++ ...uto_check_sbp_ssr_MsgSsrOrbitClockBounds.c | 368 +++++ ...bp_ssr_MsgSsrOrbitClockBoundsDegradation.c | 360 +++++ .../auto_check_sbp_ssr_MsgSsrStecCorrection.c | 408 ++++++ .../auto_check_sbp_ssr_MsgSsrTileDefinition.c | 315 ++++ c/test/check_main.c | 20 + c/test/check_main_legacy.c | 26 + c/test/check_suites.h | 14 + c/test/check_suites_legacy.h | 15 + ...check_sbp_integrity_MsgSsrFlagHighLevel.cc | 256 ++++ ...integrity_MsgSsrFlagIonoGridPointSatLos.cc | 207 +++ ..._sbp_integrity_MsgSsrFlagIonoGridPoints.cc | 206 +++ ..._sbp_integrity_MsgSsrFlagIonoTileSatLos.cc | 197 +++ ...heck_sbp_integrity_MsgSsrFlagSatellites.cc | 176 +++ ...sbp_integrity_MsgSsrFlagTropoGridPoints.cc | 207 +++ ...o_check_sbp_navigation_MsgGPSLeapSecond.cc | 170 +++ .../cpp/auto_check_sbp_navigation_MsgItrf.cc | 726 +++++++++ ...eck_sbp_ssr_MsgSsrCodePhaseBiasesBounds.cc | 257 ++++ ...k_sbp_ssr_MsgSsrGriddedCorrectionBounds.cc | 319 ++++ ...to_check_sbp_ssr_MsgSsrOrbitClockBounds.cc | 257 ++++ ...p_ssr_MsgSsrOrbitClockBoundsDegradation.cc | 243 +++ ...auto_check_sbp_ssr_MsgSsrStecCorrection.cc | 292 ++++ ...auto_check_sbp_ssr_MsgSsrTileDefinition.cc | 226 +++ ..._check_sbp_integrity_MsgSsrFlagHighLevel.c | 455 ++++++ ..._integrity_MsgSsrFlagIonoGridPointSatLos.c | 377 +++++ ...k_sbp_integrity_MsgSsrFlagIonoGridPoints.c | 375 +++++ ...k_sbp_integrity_MsgSsrFlagIonoTileSatLos.c | 359 +++++ ...check_sbp_integrity_MsgSsrFlagSatellites.c | 326 +++++ ..._sbp_integrity_MsgSsrFlagTropoGridPoints.c | 375 +++++ ...to_check_sbp_navigation_MsgGPSLeapSecond.c | 316 ++++ .../auto_check_sbp_navigation_MsgItrf.c | 1200 +++++++++++++++ ...heck_sbp_ssr_MsgSsrCodePhaseBiasesBounds.c | 455 ++++++ ...ck_sbp_ssr_MsgSsrGriddedCorrectionBounds.c | 553 +++++++ ...uto_check_sbp_ssr_MsgSsrOrbitClockBounds.c | 454 ++++++ ...bp_ssr_MsgSsrOrbitClockBoundsDegradation.c | 432 ++++++ .../auto_check_sbp_ssr_MsgSsrStecCorrection.c | 510 +++++++ .../auto_check_sbp_ssr_MsgSsrTileDefinition.c | 405 +++++ ...check_sbp_integrity_MsgSsrFlagHighLevel.cc | 325 +++++ ...integrity_MsgSsrFlagIonoGridPointSatLos.cc | 258 ++++ ..._sbp_integrity_MsgSsrFlagIonoGridPoints.cc | 254 ++++ ..._sbp_integrity_MsgSsrFlagIonoTileSatLos.cc | 241 +++ ...heck_sbp_integrity_MsgSsrFlagSatellites.cc | 212 +++ ...sbp_integrity_MsgSsrFlagTropoGridPoints.cc | 254 ++++ ...o_check_sbp_navigation_MsgGPSLeapSecond.cc | 199 +++ .../cpp/auto_check_sbp_navigation_MsgItrf.cc | 1008 +++++++++++++ ...eck_sbp_ssr_MsgSsrCodePhaseBiasesBounds.cc | 328 +++++ ...k_sbp_ssr_MsgSsrGriddedCorrectionBounds.cc | 430 ++++++ ...to_check_sbp_ssr_MsgSsrOrbitClockBounds.cc | 332 +++++ ...p_ssr_MsgSsrOrbitClockBoundsDegradation.cc | 313 ++++ ...auto_check_sbp_ssr_MsgSsrStecCorrection.cc | 383 +++++ ...auto_check_sbp_ssr_MsgSsrTileDefinition.cc | 286 ++++ docs/sbp.pdf | Bin 457850 -> 458954 bytes haskell/sbp.cabal | 1 + haskell/src/SwiftNav/SBP.hs | 1 + haskell/src/SwiftNav/SBP/Integrity.hs | 151 ++ haskell/src/SwiftNav/SBP/Msg.hs | 85 ++ haskell/src/SwiftNav/SBP/Navigation.hs | 42 + haskell/src/SwiftNav/SBP/Ssr.hs | 207 ++- .../com/swiftnav/sbp/client/MessageTable.java | 42 + .../sbp/integrity/MsgSsrFlagHighLevel.java | 58 + .../MsgSsrFlagIonoGridPointSatLos.java | 58 + .../integrity/MsgSsrFlagIonoGridPoints.java | 58 + .../integrity/MsgSsrFlagIonoTileSatLos.java | 58 + .../sbp/integrity/MsgSsrFlagSatellites.java | 58 + .../integrity/MsgSsrFlagTropoGridPoints.java | 58 + .../sbp/navigation/MsgGPSLeapSecond.java | 66 + .../com/swiftnav/sbp/navigation/MsgItrf.java | 57 + .../sbp/ssr/MsgSsrCodePhaseBiasesBounds.java | 58 + .../ssr/MsgSsrGriddedCorrectionBounds.java | 58 + .../sbp/ssr/MsgSsrOrbitClockBounds.java | 58 + .../MsgSsrOrbitClockBoundsDegradation.java | 58 + .../sbp/ssr/MsgSsrStecCorrection.java | 31 +- .../sbp/ssr/MsgSsrStecCorrectionDep.java | 77 + .../sbp/ssr/MsgSsrTileDefinition.java | 111 +- .../sbp/ssr/MsgSsrTileDefinitionDep.java | 168 +++ ...sbp_integrity_MsgSsrFlagHighLevelTest.java | 358 +++++ ...ity_MsgSsrFlagIonoGridPointSatLosTest.java | 259 ++++ ...ntegrity_MsgSsrFlagIonoGridPointsTest.java | 257 ++++ ...ntegrity_MsgSsrFlagIonoTileSatLosTest.java | 238 +++ ...bp_integrity_MsgSsrFlagSatellitesTest.java | 184 +++ ...tegrity_MsgSsrFlagTropoGridPointsTest.java | 257 ++++ ...k_sbp_navigation_MsgGPSLeapSecondTest.java | 170 +++ ...auto_check_sbp_navigation_MsgItrfTest.java | 1297 +++++++++++++++++ ...p_ssr_MsgSsrCodePhaseBiasesBoundsTest.java | 334 +++++ ...ssr_MsgSsrGriddedCorrectionBoundsTest.java | 461 ++++++ ...MsgSsrOrbitClockBoundsDegradationTest.java | 334 +++++ ...ck_sbp_ssr_MsgSsrOrbitClockBoundsTest.java | 337 +++++ ...heck_sbp_ssr_MsgSsrStecCorrectionTest.java | 401 +++++ ...heck_sbp_ssr_MsgSsrTileDefinitionTest.java | 297 ++++ javascript/sbp.bundle.js | 4 +- javascript/sbp/integrity.js | 202 +++ javascript/sbp/msg.js | 1 + javascript/sbp/navigation.js | 58 + javascript/sbp/ssr.js | 231 ++- jsonschema/MsgGPSLeapSecond.json | 24 + jsonschema/MsgItrf.json | 24 + jsonschema/MsgSsrCodePhaseBiasesBounds.json | 24 + jsonschema/MsgSsrFlagHighLevel.json | 24 + jsonschema/MsgSsrFlagIonoGridPointSatLos.json | 24 + jsonschema/MsgSsrFlagIonoGridPoints.json | 24 + jsonschema/MsgSsrFlagIonoTileSatLos.json | 24 + jsonschema/MsgSsrFlagSatellites.json | 24 + jsonschema/MsgSsrFlagTropoGridPoints.json | 24 + jsonschema/MsgSsrGriddedCorrectionBounds.json | 24 + jsonschema/MsgSsrOrbitClockBounds.json | 24 + .../MsgSsrOrbitClockBoundsDegradation.json | 24 + jsonschema/MsgSsrStecCorrection.json | 8 +- jsonschema/MsgSsrTileDefinition.json | 20 +- proto/integrity.proto | 70 + proto/navigation.proto | 18 + proto/ssr.proto | 52 +- python/docs/source/spelling_wordlist.txt | 5 + python/sbp/integrity.py | 558 +++++++ python/sbp/navigation.py | 178 +++ python/sbp/ssr.py | 567 ++++++- python/sbp/table.py | 4 +- python/tests/sbp/test_table.py | 4 +- rust/sbp/src/messages/integrity.rs | 423 ++++++ rust/sbp/src/messages/mod.rs | 339 ++++- rust/sbp/src/messages/navigation.rs | 140 ++ rust/sbp/src/messages/ssr.rs | 449 +++++- ...k_sbp_integrity_msg_ssr_flag_high_level.rs | 206 +++ ...ty_msg_ssr_flag_iono_grid_point_sat_los.rs | 156 ++ ...integrity_msg_ssr_flag_iono_grid_points.rs | 156 ++ ...ntegrity_msg_ssr_flag_iono_tile_sat_los.rs | 146 ++ ...k_sbp_integrity_msg_ssr_flag_satellites.rs | 125 ++ ...ntegrity_msg_ssr_flag_tropo_grid_points.rs | 156 ++ ...heck_sbp_navigation_msg_gps_leap_second.rs | 120 ++ .../auto_check_sbp_navigation_msg_itrf.rs | 674 +++++++++ ...bp_ssr_msg_ssr_code_phase_biases_bounds.rs | 206 +++ ...p_ssr_msg_ssr_gridded_correction_bounds.rs | 267 ++++ ...heck_sbp_ssr_msg_ssr_orbit_clock_bounds.rs | 206 +++ ..._msg_ssr_orbit_clock_bounds_degradation.rs | 191 +++ ...o_check_sbp_ssr_msg_ssr_stec_correction.rs | 241 +++ ...o_check_sbp_ssr_msg_ssr_tile_definition.rs | 176 +++ rust/sbp/tests/integration/main.rs | 14 + sbpjson/elm/SbpJson.elm | 430 ++++-- sbpjson/javascript/SbpJson.js | 209 ++- sbpjson/typescript/SbpJson.ts | 305 +++- .../integrity/test_MsgSsrFlagHighLevel.yaml | 23 + .../test_MsgSsrFlagIonoGridPointSatLos.yaml | 23 + .../test_MsgSsrFlagIonoGridPoints.yaml | 23 + .../test_MsgSsrFlagIonoTileSatLos.yaml | 23 + .../integrity/test_MsgSsrFlagSatellites.yaml | 23 + .../test_MsgSsrFlagTropoGridPoints.yaml | 23 + .../sbp/navigation/test_MsgGPSLeapSecond.yaml | 24 + .../swiftnav/sbp/navigation/test_MsgItrf.yaml | 34 + .../ssr/test_MsgSsrCodePhaseBiasesBounds.yaml | 23 + .../test_MsgSsrGriddedCorrectionBounds.yaml | 24 + .../sbp/ssr/test_MsgSsrOrbitClockBounds.yaml | 23 + ...est_MsgSsrOrbitClockBoundsDegradation.yaml | 25 + .../sbp/ssr/test_MsgSsrStecCorrection.yaml | 23 + .../sbp/ssr/test_MsgSsrTileDefinition.yaml | 23 + spec/yaml/swiftnav/sbp/integrity.yaml | 71 + spec/yaml/swiftnav/sbp/navigation.yaml | 21 + spec/yaml/swiftnav/sbp/ssr.yaml | 76 +- 202 files changed, 40455 insertions(+), 636 deletions(-) create mode 100644 c/include/libsbp/integrity.h create mode 100644 c/include/libsbp/integrity_macros.h create mode 100644 c/include/libsbp/legacy/integrity.h create mode 100644 c/include/libsbp/v4/integrity.h create mode 100644 c/include/libsbp/v4/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h create mode 100644 c/include/libsbp/v4/integrity/MSG_SSR_FLAG_IONO_GRID_POINTS.h create mode 100644 c/include/libsbp/v4/integrity/MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS.h create mode 100644 c/include/libsbp/v4/integrity/MSG_SSR_FLAG_IONO_TILE_SAT_LOS.h create mode 100644 c/include/libsbp/v4/integrity/MSG_SSR_FLAG_SATELLITES.h create mode 100644 c/include/libsbp/v4/integrity/MSG_SSR_FLAG_TROPO_GRID_POINTS.h create mode 100644 c/include/libsbp/v4/navigation/MSG_GPS_LEAP_SECOND.h create mode 100644 c/include/libsbp/v4/navigation/MSG_ITRF.h create mode 100644 c/include/libsbp/v4/ssr/MSG_SSR_CODE_PHASE_BIASES_BOUNDS.h create mode 100644 c/include/libsbp/v4/ssr/MSG_SSR_GRIDDED_CORRECTION_BOUNDS.h create mode 100644 c/include/libsbp/v4/ssr/MSG_SSR_ORBIT_CLOCK_BOUNDS.h create mode 100644 c/include/libsbp/v4/ssr/MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION.h create mode 100644 c/include/libsbp/v4/ssr/MSG_SSR_STEC_CORRECTION_DEP.h create mode 100644 c/include/libsbp/v4/ssr/MSG_SSR_TILE_DEFINITION_DEP.h create mode 100644 c/src/include/libsbp/internal/v4/integrity.h create mode 100644 c/src/v4/integrity.c create mode 100644 c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c create mode 100644 c/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos.c create mode 100644 c/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints.c create mode 100644 c/test/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos.c create mode 100644 c/test/auto_check_sbp_integrity_MsgSsrFlagSatellites.c create mode 100644 c/test/auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints.c create mode 100644 c/test/auto_check_sbp_navigation_MsgGPSLeapSecond.c create mode 100644 c/test/auto_check_sbp_navigation_MsgItrf.c create mode 100644 c/test/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds.c create mode 100644 c/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds.c create mode 100644 c/test/auto_check_sbp_ssr_MsgSsrOrbitClockBounds.c create mode 100644 c/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation.c create mode 100644 c/test/auto_check_sbp_ssr_MsgSsrStecCorrection.c create mode 100644 c/test/auto_check_sbp_ssr_MsgSsrTileDefinition.c create mode 100644 c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc create mode 100644 c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos.cc create mode 100644 c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints.cc create mode 100644 c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos.cc create mode 100644 c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagSatellites.cc create mode 100644 c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints.cc create mode 100644 c/test/cpp/auto_check_sbp_navigation_MsgGPSLeapSecond.cc create mode 100644 c/test/cpp/auto_check_sbp_navigation_MsgItrf.cc create mode 100644 c/test/cpp/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds.cc create mode 100644 c/test/cpp/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds.cc create mode 100644 c/test/cpp/auto_check_sbp_ssr_MsgSsrOrbitClockBounds.cc create mode 100644 c/test/cpp/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation.cc create mode 100644 c/test/cpp/auto_check_sbp_ssr_MsgSsrStecCorrection.cc create mode 100644 c/test/cpp/auto_check_sbp_ssr_MsgSsrTileDefinition.cc create mode 100644 c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c create mode 100644 c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos.c create mode 100644 c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints.c create mode 100644 c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos.c create mode 100644 c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagSatellites.c create mode 100644 c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints.c create mode 100644 c/test/legacy/auto_check_sbp_navigation_MsgGPSLeapSecond.c create mode 100644 c/test/legacy/auto_check_sbp_navigation_MsgItrf.c create mode 100644 c/test/legacy/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds.c create mode 100644 c/test/legacy/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds.c create mode 100644 c/test/legacy/auto_check_sbp_ssr_MsgSsrOrbitClockBounds.c create mode 100644 c/test/legacy/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation.c create mode 100644 c/test/legacy/auto_check_sbp_ssr_MsgSsrStecCorrection.c create mode 100644 c/test/legacy/auto_check_sbp_ssr_MsgSsrTileDefinition.c create mode 100644 c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc create mode 100644 c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos.cc create mode 100644 c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints.cc create mode 100644 c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos.cc create mode 100644 c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagSatellites.cc create mode 100644 c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints.cc create mode 100644 c/test/legacy/cpp/auto_check_sbp_navigation_MsgGPSLeapSecond.cc create mode 100644 c/test/legacy/cpp/auto_check_sbp_navigation_MsgItrf.cc create mode 100644 c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds.cc create mode 100644 c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds.cc create mode 100644 c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrOrbitClockBounds.cc create mode 100644 c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation.cc create mode 100644 c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrStecCorrection.cc create mode 100644 c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrTileDefinition.cc create mode 100644 haskell/src/SwiftNav/SBP/Integrity.hs create mode 100644 java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevel.java create mode 100644 java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoGridPointSatLos.java create mode 100644 java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoGridPoints.java create mode 100644 java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoTileSatLos.java create mode 100644 java/src/com/swiftnav/sbp/integrity/MsgSsrFlagSatellites.java create mode 100644 java/src/com/swiftnav/sbp/integrity/MsgSsrFlagTropoGridPoints.java create mode 100644 java/src/com/swiftnav/sbp/navigation/MsgGPSLeapSecond.java create mode 100644 java/src/com/swiftnav/sbp/navigation/MsgItrf.java create mode 100644 java/src/com/swiftnav/sbp/ssr/MsgSsrCodePhaseBiasesBounds.java create mode 100644 java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrectionBounds.java create mode 100644 java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockBounds.java create mode 100644 java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockBoundsDegradation.java create mode 100644 java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrectionDep.java create mode 100644 java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinitionDep.java create mode 100644 java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java create mode 100644 java/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLosTest.java create mode 100644 java/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointsTest.java create mode 100644 java/test/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLosTest.java create mode 100644 java/test/auto_check_sbp_integrity_MsgSsrFlagSatellitesTest.java create mode 100644 java/test/auto_check_sbp_integrity_MsgSsrFlagTropoGridPointsTest.java create mode 100644 java/test/auto_check_sbp_navigation_MsgGPSLeapSecondTest.java create mode 100644 java/test/auto_check_sbp_navigation_MsgItrfTest.java create mode 100644 java/test/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBoundsTest.java create mode 100644 java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBoundsTest.java create mode 100644 java/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradationTest.java create mode 100644 java/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsTest.java create mode 100644 java/test/auto_check_sbp_ssr_MsgSsrStecCorrectionTest.java create mode 100644 java/test/auto_check_sbp_ssr_MsgSsrTileDefinitionTest.java create mode 100644 javascript/sbp/integrity.js create mode 100644 jsonschema/MsgGPSLeapSecond.json create mode 100644 jsonschema/MsgItrf.json create mode 100644 jsonschema/MsgSsrCodePhaseBiasesBounds.json create mode 100644 jsonschema/MsgSsrFlagHighLevel.json create mode 100644 jsonschema/MsgSsrFlagIonoGridPointSatLos.json create mode 100644 jsonschema/MsgSsrFlagIonoGridPoints.json create mode 100644 jsonschema/MsgSsrFlagIonoTileSatLos.json create mode 100644 jsonschema/MsgSsrFlagSatellites.json create mode 100644 jsonschema/MsgSsrFlagTropoGridPoints.json create mode 100644 jsonschema/MsgSsrGriddedCorrectionBounds.json create mode 100644 jsonschema/MsgSsrOrbitClockBounds.json create mode 100644 jsonschema/MsgSsrOrbitClockBoundsDegradation.json create mode 100644 proto/integrity.proto create mode 100644 python/sbp/integrity.py create mode 100644 rust/sbp/src/messages/integrity.rs create mode 100644 rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs create mode 100644 rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_iono_grid_point_sat_los.rs create mode 100644 rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_iono_grid_points.rs create mode 100644 rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_iono_tile_sat_los.rs create mode 100644 rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_satellites.rs create mode 100644 rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_tropo_grid_points.rs create mode 100644 rust/sbp/tests/integration/auto_check_sbp_navigation_msg_gps_leap_second.rs create mode 100644 rust/sbp/tests/integration/auto_check_sbp_navigation_msg_itrf.rs create mode 100644 rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_code_phase_biases_bounds.rs create mode 100644 rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_gridded_correction_bounds.rs create mode 100644 rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_orbit_clock_bounds.rs create mode 100644 rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_orbit_clock_bounds_degradation.rs create mode 100644 rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_stec_correction.rs create mode 100644 rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_tile_definition.rs create mode 100644 spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml create mode 100644 spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPointSatLos.yaml create mode 100644 spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPoints.yaml create mode 100644 spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoTileSatLos.yaml create mode 100644 spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagSatellites.yaml create mode 100644 spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagTropoGridPoints.yaml create mode 100644 spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSLeapSecond.yaml create mode 100644 spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml create mode 100644 spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrCodePhaseBiasesBounds.yaml create mode 100644 spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrectionBounds.yaml create mode 100644 spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBounds.yaml create mode 100644 spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBoundsDegradation.yaml create mode 100644 spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrStecCorrection.yaml create mode 100644 spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrTileDefinition.yaml create mode 100644 spec/yaml/swiftnav/sbp/integrity.yaml diff --git a/c/include/libsbp/cpp/message_traits.h b/c/include/libsbp/cpp/message_traits.h index 9d61f6f7db..e1c7054f73 100644 --- a/c/include/libsbp/cpp/message_traits.h +++ b/c/include/libsbp/cpp/message_traits.h @@ -24,6 +24,7 @@ #include #include #include +#include #include #include #include @@ -2687,6 +2688,41 @@ struct MessageTraits { } }; +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgGpsLeapSecond; + static const sbp_msg_gps_leap_second_t &get(const sbp_msg_t &msg) { + return msg.gps_leap_second; + } + static sbp_msg_gps_leap_second_t &get(sbp_msg_t &msg) { + return msg.gps_leap_second; + } + static void to_sbp_msg(const sbp_msg_gps_leap_second_t &msg, + sbp_msg_t *sbp_msg) { + sbp_msg->gps_leap_second = msg; + } + static sbp_msg_t to_sbp_msg(const sbp_msg_gps_leap_second_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.gps_leap_second = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, + const sbp_msg_gps_leap_second_t &msg, sbp_write_fn_t write) { + return sbp_msg_gps_leap_second_send(state, sender_id, &msg, write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_gps_leap_second_t &msg) { + return sbp_msg_gps_leap_second_encode(buf, len, n_written, &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_gps_leap_second_t *msg) { + return sbp_msg_gps_leap_second_decode(buf, len, n_read, msg); + } + static size_t encoded_len(const sbp_msg_gps_leap_second_t &msg) { + return sbp_msg_gps_leap_second_encoded_len(&msg); + } +}; + template <> struct MessageTraits { static constexpr sbp_msg_type_t id = SbpMsgGpsTimeDepA; @@ -3198,6 +3234,36 @@ struct MessageTraits { } }; +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgItrf; + static const sbp_msg_itrf_t &get(const sbp_msg_t &msg) { return msg.itrf; } + static sbp_msg_itrf_t &get(sbp_msg_t &msg) { return msg.itrf; } + static void to_sbp_msg(const sbp_msg_itrf_t &msg, sbp_msg_t *sbp_msg) { + sbp_msg->itrf = msg; + } + static sbp_msg_t to_sbp_msg(const sbp_msg_itrf_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.itrf = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, const sbp_msg_itrf_t &msg, + sbp_write_fn_t write) { + return sbp_msg_itrf_send(state, sender_id, &msg, write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_itrf_t &msg) { + return sbp_msg_itrf_encode(buf, len, n_written, &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_itrf_t *msg) { + return sbp_msg_itrf_decode(buf, len, n_read, msg); + } + static size_t encoded_len(const sbp_msg_itrf_t &msg) { + return sbp_msg_itrf_encoded_len(&msg); + } +}; + template <> struct MessageTraits { static constexpr sbp_msg_type_t id = SbpMsgLinuxCpuStateDepA; @@ -5581,6 +5647,271 @@ struct MessageTraits { } }; +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgSsrCodePhaseBiasesBounds; + static const sbp_msg_ssr_code_phase_biases_bounds_t &get( + const sbp_msg_t &msg) { + return msg.ssr_code_phase_biases_bounds; + } + static sbp_msg_ssr_code_phase_biases_bounds_t &get(sbp_msg_t &msg) { + return msg.ssr_code_phase_biases_bounds; + } + static void to_sbp_msg(const sbp_msg_ssr_code_phase_biases_bounds_t &msg, + sbp_msg_t *sbp_msg) { + sbp_msg->ssr_code_phase_biases_bounds = msg; + } + static sbp_msg_t to_sbp_msg( + const sbp_msg_ssr_code_phase_biases_bounds_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.ssr_code_phase_biases_bounds = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, + const sbp_msg_ssr_code_phase_biases_bounds_t &msg, + sbp_write_fn_t write) { + return sbp_msg_ssr_code_phase_biases_bounds_send(state, sender_id, &msg, + write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_code_phase_biases_bounds_t &msg) { + return sbp_msg_ssr_code_phase_biases_bounds_encode(buf, len, n_written, + &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_code_phase_biases_bounds_t *msg) { + return sbp_msg_ssr_code_phase_biases_bounds_decode(buf, len, n_read, msg); + } + static size_t encoded_len(const sbp_msg_ssr_code_phase_biases_bounds_t &msg) { + return sbp_msg_ssr_code_phase_biases_bounds_encoded_len(&msg); + } +}; + +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgSsrFlagHighLevel; + static const sbp_msg_ssr_flag_high_level_t &get(const sbp_msg_t &msg) { + return msg.ssr_flag_high_level; + } + static sbp_msg_ssr_flag_high_level_t &get(sbp_msg_t &msg) { + return msg.ssr_flag_high_level; + } + static void to_sbp_msg(const sbp_msg_ssr_flag_high_level_t &msg, + sbp_msg_t *sbp_msg) { + sbp_msg->ssr_flag_high_level = msg; + } + static sbp_msg_t to_sbp_msg(const sbp_msg_ssr_flag_high_level_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.ssr_flag_high_level = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, + const sbp_msg_ssr_flag_high_level_t &msg, + sbp_write_fn_t write) { + return sbp_msg_ssr_flag_high_level_send(state, sender_id, &msg, write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_high_level_t &msg) { + return sbp_msg_ssr_flag_high_level_encode(buf, len, n_written, &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_high_level_t *msg) { + return sbp_msg_ssr_flag_high_level_decode(buf, len, n_read, msg); + } + static size_t encoded_len(const sbp_msg_ssr_flag_high_level_t &msg) { + return sbp_msg_ssr_flag_high_level_encoded_len(&msg); + } +}; + +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgSsrFlagIonoGridPointSatLos; + static const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &get( + const sbp_msg_t &msg) { + return msg.ssr_flag_iono_grid_point_sat_los; + } + static sbp_msg_ssr_flag_iono_grid_point_sat_los_t &get(sbp_msg_t &msg) { + return msg.ssr_flag_iono_grid_point_sat_los; + } + static void to_sbp_msg(const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &msg, + sbp_msg_t *sbp_msg) { + sbp_msg->ssr_flag_iono_grid_point_sat_los = msg; + } + static sbp_msg_t to_sbp_msg( + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.ssr_flag_iono_grid_point_sat_los = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &msg, + sbp_write_fn_t write) { + return sbp_msg_ssr_flag_iono_grid_point_sat_los_send(state, sender_id, &msg, + write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &msg) { + return sbp_msg_ssr_flag_iono_grid_point_sat_los_encode(buf, len, n_written, + &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_iono_grid_point_sat_los_t *msg) { + return sbp_msg_ssr_flag_iono_grid_point_sat_los_decode(buf, len, n_read, + msg); + } + static size_t encoded_len( + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &msg) { + return sbp_msg_ssr_flag_iono_grid_point_sat_los_encoded_len(&msg); + } +}; + +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgSsrFlagIonoGridPoints; + static const sbp_msg_ssr_flag_iono_grid_points_t &get(const sbp_msg_t &msg) { + return msg.ssr_flag_iono_grid_points; + } + static sbp_msg_ssr_flag_iono_grid_points_t &get(sbp_msg_t &msg) { + return msg.ssr_flag_iono_grid_points; + } + static void to_sbp_msg(const sbp_msg_ssr_flag_iono_grid_points_t &msg, + sbp_msg_t *sbp_msg) { + sbp_msg->ssr_flag_iono_grid_points = msg; + } + static sbp_msg_t to_sbp_msg(const sbp_msg_ssr_flag_iono_grid_points_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.ssr_flag_iono_grid_points = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, + const sbp_msg_ssr_flag_iono_grid_points_t &msg, + sbp_write_fn_t write) { + return sbp_msg_ssr_flag_iono_grid_points_send(state, sender_id, &msg, + write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_iono_grid_points_t &msg) { + return sbp_msg_ssr_flag_iono_grid_points_encode(buf, len, n_written, &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_iono_grid_points_t *msg) { + return sbp_msg_ssr_flag_iono_grid_points_decode(buf, len, n_read, msg); + } + static size_t encoded_len(const sbp_msg_ssr_flag_iono_grid_points_t &msg) { + return sbp_msg_ssr_flag_iono_grid_points_encoded_len(&msg); + } +}; + +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgSsrFlagIonoTileSatLos; + static const sbp_msg_ssr_flag_iono_tile_sat_los_t &get(const sbp_msg_t &msg) { + return msg.ssr_flag_iono_tile_sat_los; + } + static sbp_msg_ssr_flag_iono_tile_sat_los_t &get(sbp_msg_t &msg) { + return msg.ssr_flag_iono_tile_sat_los; + } + static void to_sbp_msg(const sbp_msg_ssr_flag_iono_tile_sat_los_t &msg, + sbp_msg_t *sbp_msg) { + sbp_msg->ssr_flag_iono_tile_sat_los = msg; + } + static sbp_msg_t to_sbp_msg(const sbp_msg_ssr_flag_iono_tile_sat_los_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.ssr_flag_iono_tile_sat_los = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, + const sbp_msg_ssr_flag_iono_tile_sat_los_t &msg, + sbp_write_fn_t write) { + return sbp_msg_ssr_flag_iono_tile_sat_los_send(state, sender_id, &msg, + write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_iono_tile_sat_los_t &msg) { + return sbp_msg_ssr_flag_iono_tile_sat_los_encode(buf, len, n_written, &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_iono_tile_sat_los_t *msg) { + return sbp_msg_ssr_flag_iono_tile_sat_los_decode(buf, len, n_read, msg); + } + static size_t encoded_len(const sbp_msg_ssr_flag_iono_tile_sat_los_t &msg) { + return sbp_msg_ssr_flag_iono_tile_sat_los_encoded_len(&msg); + } +}; + +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgSsrFlagSatellites; + static const sbp_msg_ssr_flag_satellites_t &get(const sbp_msg_t &msg) { + return msg.ssr_flag_satellites; + } + static sbp_msg_ssr_flag_satellites_t &get(sbp_msg_t &msg) { + return msg.ssr_flag_satellites; + } + static void to_sbp_msg(const sbp_msg_ssr_flag_satellites_t &msg, + sbp_msg_t *sbp_msg) { + sbp_msg->ssr_flag_satellites = msg; + } + static sbp_msg_t to_sbp_msg(const sbp_msg_ssr_flag_satellites_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.ssr_flag_satellites = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, + const sbp_msg_ssr_flag_satellites_t &msg, + sbp_write_fn_t write) { + return sbp_msg_ssr_flag_satellites_send(state, sender_id, &msg, write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_satellites_t &msg) { + return sbp_msg_ssr_flag_satellites_encode(buf, len, n_written, &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_satellites_t *msg) { + return sbp_msg_ssr_flag_satellites_decode(buf, len, n_read, msg); + } + static size_t encoded_len(const sbp_msg_ssr_flag_satellites_t &msg) { + return sbp_msg_ssr_flag_satellites_encoded_len(&msg); + } +}; + +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgSsrFlagTropoGridPoints; + static const sbp_msg_ssr_flag_tropo_grid_points_t &get(const sbp_msg_t &msg) { + return msg.ssr_flag_tropo_grid_points; + } + static sbp_msg_ssr_flag_tropo_grid_points_t &get(sbp_msg_t &msg) { + return msg.ssr_flag_tropo_grid_points; + } + static void to_sbp_msg(const sbp_msg_ssr_flag_tropo_grid_points_t &msg, + sbp_msg_t *sbp_msg) { + sbp_msg->ssr_flag_tropo_grid_points = msg; + } + static sbp_msg_t to_sbp_msg(const sbp_msg_ssr_flag_tropo_grid_points_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.ssr_flag_tropo_grid_points = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, + const sbp_msg_ssr_flag_tropo_grid_points_t &msg, + sbp_write_fn_t write) { + return sbp_msg_ssr_flag_tropo_grid_points_send(state, sender_id, &msg, + write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_tropo_grid_points_t &msg) { + return sbp_msg_ssr_flag_tropo_grid_points_encode(buf, len, n_written, &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_tropo_grid_points_t *msg) { + return sbp_msg_ssr_flag_tropo_grid_points_decode(buf, len, n_read, msg); + } + static size_t encoded_len(const sbp_msg_ssr_flag_tropo_grid_points_t &msg) { + return sbp_msg_ssr_flag_tropo_grid_points_encoded_len(&msg); + } +}; + template <> struct MessageTraits { static constexpr sbp_msg_type_t id = SbpMsgSsrGridDefinitionDepA; @@ -5618,6 +5949,47 @@ struct MessageTraits { } }; +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgSsrGriddedCorrectionBounds; + static const sbp_msg_ssr_gridded_correction_bounds_t &get( + const sbp_msg_t &msg) { + return msg.ssr_gridded_correction_bounds; + } + static sbp_msg_ssr_gridded_correction_bounds_t &get(sbp_msg_t &msg) { + return msg.ssr_gridded_correction_bounds; + } + static void to_sbp_msg(const sbp_msg_ssr_gridded_correction_bounds_t &msg, + sbp_msg_t *sbp_msg) { + sbp_msg->ssr_gridded_correction_bounds = msg; + } + static sbp_msg_t to_sbp_msg( + const sbp_msg_ssr_gridded_correction_bounds_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.ssr_gridded_correction_bounds = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, + const sbp_msg_ssr_gridded_correction_bounds_t &msg, + sbp_write_fn_t write) { + return sbp_msg_ssr_gridded_correction_bounds_send(state, sender_id, &msg, + write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_gridded_correction_bounds_t &msg) { + return sbp_msg_ssr_gridded_correction_bounds_encode(buf, len, n_written, + &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_gridded_correction_bounds_t *msg) { + return sbp_msg_ssr_gridded_correction_bounds_decode(buf, len, n_read, msg); + } + static size_t encoded_len( + const sbp_msg_ssr_gridded_correction_bounds_t &msg) { + return sbp_msg_ssr_gridded_correction_bounds_encoded_len(&msg); + } +}; + template <> struct MessageTraits { static constexpr sbp_msg_type_t id = SbpMsgSsrGriddedCorrectionDepA; @@ -5737,6 +6109,85 @@ struct MessageTraits { } }; +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgSsrOrbitClockBoundsDegradation; + static const sbp_msg_ssr_orbit_clock_bounds_degradation_t &get( + const sbp_msg_t &msg) { + return msg.ssr_orbit_clock_bounds_degradation; + } + static sbp_msg_ssr_orbit_clock_bounds_degradation_t &get(sbp_msg_t &msg) { + return msg.ssr_orbit_clock_bounds_degradation; + } + static void to_sbp_msg( + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &msg, + sbp_msg_t *sbp_msg) { + sbp_msg->ssr_orbit_clock_bounds_degradation = msg; + } + static sbp_msg_t to_sbp_msg( + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.ssr_orbit_clock_bounds_degradation = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &msg, + sbp_write_fn_t write) { + return sbp_msg_ssr_orbit_clock_bounds_degradation_send(state, sender_id, + &msg, write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &msg) { + return sbp_msg_ssr_orbit_clock_bounds_degradation_encode(buf, len, + n_written, &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_orbit_clock_bounds_degradation_t *msg) { + return sbp_msg_ssr_orbit_clock_bounds_degradation_decode(buf, len, n_read, + msg); + } + static size_t encoded_len( + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &msg) { + return sbp_msg_ssr_orbit_clock_bounds_degradation_encoded_len(&msg); + } +}; + +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgSsrOrbitClockBounds; + static const sbp_msg_ssr_orbit_clock_bounds_t &get(const sbp_msg_t &msg) { + return msg.ssr_orbit_clock_bounds; + } + static sbp_msg_ssr_orbit_clock_bounds_t &get(sbp_msg_t &msg) { + return msg.ssr_orbit_clock_bounds; + } + static void to_sbp_msg(const sbp_msg_ssr_orbit_clock_bounds_t &msg, + sbp_msg_t *sbp_msg) { + sbp_msg->ssr_orbit_clock_bounds = msg; + } + static sbp_msg_t to_sbp_msg(const sbp_msg_ssr_orbit_clock_bounds_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.ssr_orbit_clock_bounds = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, + const sbp_msg_ssr_orbit_clock_bounds_t &msg, + sbp_write_fn_t write) { + return sbp_msg_ssr_orbit_clock_bounds_send(state, sender_id, &msg, write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_orbit_clock_bounds_t &msg) { + return sbp_msg_ssr_orbit_clock_bounds_encode(buf, len, n_written, &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_orbit_clock_bounds_t *msg) { + return sbp_msg_ssr_orbit_clock_bounds_decode(buf, len, n_read, msg); + } + static size_t encoded_len(const sbp_msg_ssr_orbit_clock_bounds_t &msg) { + return sbp_msg_ssr_orbit_clock_bounds_encoded_len(&msg); + } +}; + template <> struct MessageTraits { static constexpr sbp_msg_type_t id = SbpMsgSsrOrbitClockDepA; @@ -5915,6 +6366,42 @@ struct MessageTraits { } }; +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgSsrStecCorrectionDep; + static const sbp_msg_ssr_stec_correction_dep_t &get(const sbp_msg_t &msg) { + return msg.ssr_stec_correction_dep; + } + static sbp_msg_ssr_stec_correction_dep_t &get(sbp_msg_t &msg) { + return msg.ssr_stec_correction_dep; + } + static void to_sbp_msg(const sbp_msg_ssr_stec_correction_dep_t &msg, + sbp_msg_t *sbp_msg) { + sbp_msg->ssr_stec_correction_dep = msg; + } + static sbp_msg_t to_sbp_msg(const sbp_msg_ssr_stec_correction_dep_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.ssr_stec_correction_dep = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, + const sbp_msg_ssr_stec_correction_dep_t &msg, + sbp_write_fn_t write) { + return sbp_msg_ssr_stec_correction_dep_send(state, sender_id, &msg, write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_stec_correction_dep_t &msg) { + return sbp_msg_ssr_stec_correction_dep_encode(buf, len, n_written, &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_stec_correction_dep_t *msg) { + return sbp_msg_ssr_stec_correction_dep_decode(buf, len, n_read, msg); + } + static size_t encoded_len(const sbp_msg_ssr_stec_correction_dep_t &msg) { + return sbp_msg_ssr_stec_correction_dep_encoded_len(&msg); + } +}; + template <> struct MessageTraits { static constexpr sbp_msg_type_t id = SbpMsgSsrStecCorrection; @@ -5951,6 +6438,42 @@ struct MessageTraits { } }; +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgSsrTileDefinitionDep; + static const sbp_msg_ssr_tile_definition_dep_t &get(const sbp_msg_t &msg) { + return msg.ssr_tile_definition_dep; + } + static sbp_msg_ssr_tile_definition_dep_t &get(sbp_msg_t &msg) { + return msg.ssr_tile_definition_dep; + } + static void to_sbp_msg(const sbp_msg_ssr_tile_definition_dep_t &msg, + sbp_msg_t *sbp_msg) { + sbp_msg->ssr_tile_definition_dep = msg; + } + static sbp_msg_t to_sbp_msg(const sbp_msg_ssr_tile_definition_dep_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.ssr_tile_definition_dep = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, + const sbp_msg_ssr_tile_definition_dep_t &msg, + sbp_write_fn_t write) { + return sbp_msg_ssr_tile_definition_dep_send(state, sender_id, &msg, write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_tile_definition_dep_t &msg) { + return sbp_msg_ssr_tile_definition_dep_encode(buf, len, n_written, &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_tile_definition_dep_t *msg) { + return sbp_msg_ssr_tile_definition_dep_decode(buf, len, n_read, msg); + } + static size_t encoded_len(const sbp_msg_ssr_tile_definition_dep_t &msg) { + return sbp_msg_ssr_tile_definition_dep_encoded_len(&msg); + } +}; + template <> struct MessageTraits { static constexpr sbp_msg_type_t id = SbpMsgSsrTileDefinition; diff --git a/c/include/libsbp/integrity.h b/c/include/libsbp/integrity.h new file mode 100644 index 0000000000..20a99b3f59 --- /dev/null +++ b/c/include/libsbp/integrity.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/integrity.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_INTEGRITY_MESSAGES_H +#define LIBSBP_INTEGRITY_MESSAGES_H + +#include + +SBP_MESSAGE( + "Legacy SBP definitions have moved. To continue using legacy message " + "definitions include `libsbp/legacy/integrity.h` instead. Access to legacy " + "types via `libsbp/integrity.h` will be removed in version 5.") + +#include + +#endif /* LIBSBP_INTEGRITY_MESSAGES_H */ \ No newline at end of file diff --git a/c/include/libsbp/integrity_macros.h b/c/include/libsbp/integrity_macros.h new file mode 100644 index 0000000000..3fc8a5f428 --- /dev/null +++ b/c/include/libsbp/integrity_macros.h @@ -0,0 +1,165 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/integrity.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_INTEGRITY_MACROS_H +#define LIBSBP_INTEGRITY_MACROS_H + +#define SBP_MSG_SSR_FLAG_HIGH_LEVEL 0x0BB9 +/** + * The maximum number of items that can be stored in + * sbp_msg_ssr_flag_high_level_t::stub (V4 API) or + * msg_ssr_flag_high_level_t::stub (legacy API) before the maximum SBP message + * size is exceeded + */ +#define SBP_MSG_SSR_FLAG_HIGH_LEVEL_STUB_MAX 255u + +/** + * Encoded length of sbp_msg_ssr_flag_high_level_t (V4 API) and + * msg_ssr_flag_high_level_t (legacy API) + * + * This type is not fixed size and an instance of this message may be longer + * than the value indicated by this symbol. Users of the V4 API should call + * #sbp_msg_ssr_flag_high_level_encoded_len to determine the actual size of an + * instance of this message. Users of the legacy API are required to track the + * encoded message length when interacting with the legacy type. + * + * See the documentation for libsbp for more details regarding the message + * structure and its variable length component(s) + */ +#define SBP_MSG_SSR_FLAG_HIGH_LEVEL_ENCODED_OVERHEAD 0u + +#define SBP_MSG_SSR_FLAG_SATELLITES 0x0BBD +/** + * The maximum number of items that can be stored in + * sbp_msg_ssr_flag_satellites_t::stub (V4 API) or + * msg_ssr_flag_satellites_t::stub (legacy API) before the maximum SBP message + * size is exceeded + */ +#define SBP_MSG_SSR_FLAG_SATELLITES_STUB_MAX 255u + +/** + * Encoded length of sbp_msg_ssr_flag_satellites_t (V4 API) and + * msg_ssr_flag_satellites_t (legacy API) + * + * This type is not fixed size and an instance of this message may be longer + * than the value indicated by this symbol. Users of the V4 API should call + * #sbp_msg_ssr_flag_satellites_encoded_len to determine the actual size of an + * instance of this message. Users of the legacy API are required to track the + * encoded message length when interacting with the legacy type. + * + * See the documentation for libsbp for more details regarding the message + * structure and its variable length component(s) + */ +#define SBP_MSG_SSR_FLAG_SATELLITES_ENCODED_OVERHEAD 0u + +#define SBP_MSG_SSR_FLAG_TROPO_GRID_POINTS 0x0BC3 +/** + * The maximum number of items that can be stored in + * sbp_msg_ssr_flag_tropo_grid_points_t::stub (V4 API) or + * msg_ssr_flag_tropo_grid_points_t::stub (legacy API) before the maximum SBP + * message size is exceeded + */ +#define SBP_MSG_SSR_FLAG_TROPO_GRID_POINTS_STUB_MAX 255u + +/** + * Encoded length of sbp_msg_ssr_flag_tropo_grid_points_t (V4 API) and + * msg_ssr_flag_tropo_grid_points_t (legacy API) + * + * This type is not fixed size and an instance of this message may be longer + * than the value indicated by this symbol. Users of the V4 API should call + * #sbp_msg_ssr_flag_tropo_grid_points_encoded_len to determine the actual size + * of an instance of this message. Users of the legacy API are required to track + * the encoded message length when interacting with the legacy type. + * + * See the documentation for libsbp for more details regarding the message + * structure and its variable length component(s) + */ +#define SBP_MSG_SSR_FLAG_TROPO_GRID_POINTS_ENCODED_OVERHEAD 0u + +#define SBP_MSG_SSR_FLAG_IONO_GRID_POINTS 0x0BC7 +/** + * The maximum number of items that can be stored in + * sbp_msg_ssr_flag_iono_grid_points_t::stub (V4 API) or + * msg_ssr_flag_iono_grid_points_t::stub (legacy API) before the maximum SBP + * message size is exceeded + */ +#define SBP_MSG_SSR_FLAG_IONO_GRID_POINTS_STUB_MAX 255u + +/** + * Encoded length of sbp_msg_ssr_flag_iono_grid_points_t (V4 API) and + * msg_ssr_flag_iono_grid_points_t (legacy API) + * + * This type is not fixed size and an instance of this message may be longer + * than the value indicated by this symbol. Users of the V4 API should call + * #sbp_msg_ssr_flag_iono_grid_points_encoded_len to determine the actual size + * of an instance of this message. Users of the legacy API are required to track + * the encoded message length when interacting with the legacy type. + * + * See the documentation for libsbp for more details regarding the message + * structure and its variable length component(s) + */ +#define SBP_MSG_SSR_FLAG_IONO_GRID_POINTS_ENCODED_OVERHEAD 0u + +#define SBP_MSG_SSR_FLAG_IONO_TILE_SAT_LOS 0x0BCD +/** + * The maximum number of items that can be stored in + * sbp_msg_ssr_flag_iono_tile_sat_los_t::stub (V4 API) or + * msg_ssr_flag_iono_tile_sat_los_t::stub (legacy API) before the maximum SBP + * message size is exceeded + */ +#define SBP_MSG_SSR_FLAG_IONO_TILE_SAT_LOS_STUB_MAX 255u + +/** + * Encoded length of sbp_msg_ssr_flag_iono_tile_sat_los_t (V4 API) and + * msg_ssr_flag_iono_tile_sat_los_t (legacy API) + * + * This type is not fixed size and an instance of this message may be longer + * than the value indicated by this symbol. Users of the V4 API should call + * #sbp_msg_ssr_flag_iono_tile_sat_los_encoded_len to determine the actual size + * of an instance of this message. Users of the legacy API are required to track + * the encoded message length when interacting with the legacy type. + * + * See the documentation for libsbp for more details regarding the message + * structure and its variable length component(s) + */ +#define SBP_MSG_SSR_FLAG_IONO_TILE_SAT_LOS_ENCODED_OVERHEAD 0u + +#define SBP_MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS 0x0BD1 +/** + * The maximum number of items that can be stored in + * sbp_msg_ssr_flag_iono_grid_point_sat_los_t::stub (V4 API) or + * msg_ssr_flag_iono_grid_point_sat_los_t::stub (legacy API) before the maximum + * SBP message size is exceeded + */ +#define SBP_MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS_STUB_MAX 255u + +/** + * Encoded length of sbp_msg_ssr_flag_iono_grid_point_sat_los_t (V4 API) and + * msg_ssr_flag_iono_grid_point_sat_los_t (legacy API) + * + * This type is not fixed size and an instance of this message may be longer + * than the value indicated by this symbol. Users of the V4 API should call + * #sbp_msg_ssr_flag_iono_grid_point_sat_los_encoded_len to determine the actual + * size of an instance of this message. Users of the legacy API are required to + * track the encoded message length when interacting with the legacy type. + * + * See the documentation for libsbp for more details regarding the message + * structure and its variable length component(s) + */ +#define SBP_MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS_ENCODED_OVERHEAD 0u + +#endif /* LIBSBP_INTEGRITY_MACROS_H */ diff --git a/c/include/libsbp/legacy/cpp/message_traits.h b/c/include/libsbp/legacy/cpp/message_traits.h index 96bc1dfbe4..0d3549f8c1 100644 --- a/c/include/libsbp/legacy/cpp/message_traits.h +++ b/c/include/libsbp/legacy/cpp/message_traits.h @@ -19,6 +19,7 @@ #include #include #include +#include #include #include #include @@ -912,6 +913,18 @@ struct MessageTraits { }; +template<> +struct MessageTraits { + static constexpr u16 id = 570; +}; + + +template<> +struct MessageTraits { + static constexpr u16 id = 580; +}; + + template<> struct MessageTraits { static constexpr u16 id = 1024; @@ -942,6 +955,18 @@ struct MessageTraits { }; +template<> +struct MessageTraits { + static constexpr u16 id = 1502; +}; + + +template<> +struct MessageTraits { + static constexpr u16 id = 1503; +}; + + template<> struct MessageTraits { static constexpr u16 id = 1505; @@ -960,6 +985,12 @@ struct MessageTraits { }; +template<> +struct MessageTraits { + static constexpr u16 id = 1516; +}; + + template<> struct MessageTraits { static constexpr u16 id = 1520; @@ -973,11 +1004,17 @@ struct MessageTraits { template<> -struct MessageTraits { +struct MessageTraits { static constexpr u16 id = 1526; }; +template<> +struct MessageTraits { + static constexpr u16 id = 1527; +}; + + template<> struct MessageTraits { static constexpr u16 id = 1530; @@ -985,7 +1022,7 @@ struct MessageTraits { template<> -struct MessageTraits { +struct MessageTraits { static constexpr u16 id = 1531; }; @@ -996,6 +1033,18 @@ struct MessageTraits { }; +template<> +struct MessageTraits { + static constexpr u16 id = 1533; +}; + + +template<> +struct MessageTraits { + static constexpr u16 id = 1534; +}; + + template<> struct MessageTraits { static constexpr u16 id = 1540; @@ -1044,6 +1093,42 @@ struct MessageTraits { }; +template<> +struct MessageTraits { + static constexpr u16 id = 3001; +}; + + +template<> +struct MessageTraits { + static constexpr u16 id = 3005; +}; + + +template<> +struct MessageTraits { + static constexpr u16 id = 3011; +}; + + +template<> +struct MessageTraits { + static constexpr u16 id = 3015; +}; + + +template<> +struct MessageTraits { + static constexpr u16 id = 3021; +}; + + +template<> +struct MessageTraits { + static constexpr u16 id = 3025; +}; + + template<> struct MessageTraits { static constexpr u16 id = 4097; diff --git a/c/include/libsbp/legacy/integrity.h b/c/include/libsbp/legacy/integrity.h new file mode 100644 index 0000000000..dc9f019a0f --- /dev/null +++ b/c/include/libsbp/legacy/integrity.h @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/integrity.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +/** \defgroup integrity Integrity + * + * Integrity flag messages + * \{ */ + +#ifndef LIBSBP_LEGACY_INTEGRITY_MESSAGES_H +#define LIBSBP_LEGACY_INTEGRITY_MESSAGES_H + +#include + +#include +#include + +SBP_PACK_START + +typedef struct SBP_ATTR_PACKED { + u8 stub[0]; +} msg_ssr_flag_high_level_t; + +typedef struct SBP_ATTR_PACKED { + u8 stub[0]; +} msg_ssr_flag_satellites_t; + +typedef struct SBP_ATTR_PACKED { + u8 stub[0]; +} msg_ssr_flag_tropo_grid_points_t; + +typedef struct SBP_ATTR_PACKED { + u8 stub[0]; +} msg_ssr_flag_iono_grid_points_t; + +typedef struct SBP_ATTR_PACKED { + u8 stub[0]; +} msg_ssr_flag_iono_tile_sat_los_t; + +typedef struct SBP_ATTR_PACKED { + u8 stub[0]; +} msg_ssr_flag_iono_grid_point_sat_los_t; + +/** \} */ + +SBP_PACK_END + +#endif /* LIBSBP_LEGACY_INTEGRITY_MESSAGES_H */ \ No newline at end of file diff --git a/c/include/libsbp/legacy/navigation.h b/c/include/libsbp/legacy/navigation.h index 06c1673222..162314460f 100644 --- a/c/include/libsbp/legacy/navigation.h +++ b/c/include/libsbp/legacy/navigation.h @@ -919,6 +919,21 @@ typedef struct SBP_ATTR_PACKED { u32 flags; /**< Status flags */ } msg_protection_level_t; +/** Leap second SBP message. + + * + * Emulates the GPS CNAV message, reserving bytes for future broadcast of the + * drift model parameters. + */ + +typedef struct SBP_ATTR_PACKED { + u8 stub[0]; +} msg_gps_leap_second_t; + +typedef struct SBP_ATTR_PACKED { + u8 stub[0]; +} msg_itrf_t; + /** \} */ SBP_PACK_END diff --git a/c/include/libsbp/legacy/ssr.h b/c/include/libsbp/legacy/ssr.h index 411c9b6f2d..285a30606c 100644 --- a/c/include/libsbp/legacy/ssr.h +++ b/c/include/libsbp/legacy/ssr.h @@ -267,6 +267,10 @@ typedef struct SBP_ATTR_PACKED { stec_sat_element_t stec_sat_list[0]; /**< Array of STEC polynomial coefficients for each space vehicle. */ +} msg_ssr_stec_correction_dep_t; + +typedef struct SBP_ATTR_PACKED { + u8 stub[0]; } msg_ssr_stec_correction_t; /** Gridded troposphere and STEC correction residuals @@ -292,11 +296,15 @@ typedef struct SBP_ATTR_PACKED { satellite (mean, stddev). */ } msg_ssr_gridded_correction_t; +typedef struct SBP_ATTR_PACKED { + u8 stub[0]; +} msg_ssr_gridded_correction_bounds_t; + /** Definition of a SSR atmospheric correction tile. * * Provides the correction point coordinates for the atmospheric correction - * values in the MSG_SSR_STEC_CORRECTION and MSG_SSR_GRIDDED_CORRECTION + * values in the MSG_SSR_STEC_CORRECTION_DEP and MSG_SSR_GRIDDED_CORRECTION * messages. * * Based on ETSI TS 137 355 V16.1.0 (LTE Positioning Protocol) information @@ -365,6 +373,22 @@ typedef struct SBP_ATTR_PACKED { See GNSS-SSR-ArrayOfCorrectionPoints field bitmaskOfGrids but note the definition of the bits is inverted. */ +} msg_ssr_tile_definition_dep_t; + +/** Definition of a SSR atmospheric correction tile. + + * + * Provides the correction point coordinates for the atmospheric correction + * values in the MSG_SSR_STEC_CORRECTION and MSG_SSR_GRIDDED_CORRECTION + * messages. + * + * Based on ETSI TS 137 355 V16.1.0 (LTE Positioning Protocol) information + * element GNSS-SSR-CorrectionPoints. SBP only supports gridded arrays of + * correction points, not lists of points. + */ + +typedef struct SBP_ATTR_PACKED { + u8 stub[0]; } msg_ssr_tile_definition_t; /** Antenna phase center correction @@ -520,6 +544,18 @@ typedef struct SBP_ATTR_PACKED { are encoded as u8 integers. */ } msg_ssr_grid_definition_dep_a_t; +typedef struct SBP_ATTR_PACKED { + u8 stub[0]; +} msg_ssr_orbit_clock_bounds_t; + +typedef struct SBP_ATTR_PACKED { + u8 stub[0]; +} msg_ssr_code_phase_biases_bounds_t; + +typedef struct SBP_ATTR_PACKED { + u8 stub[0]; +} msg_ssr_orbit_clock_bounds_degradation_t; + /** \} */ SBP_PACK_END diff --git a/c/include/libsbp/navigation_macros.h b/c/include/libsbp/navigation_macros.h index 886b77ff02..bc63ea59bd 100644 --- a/c/include/libsbp/navigation_macros.h +++ b/c/include/libsbp/navigation_macros.h @@ -1736,4 +1736,50 @@ */ #define SBP_MSG_PROTECTION_LEVEL_ENCODED_LEN 76u +#define SBP_MSG_GPS_LEAP_SECOND 0x023A +/** + * The maximum number of items that can be stored in + * sbp_msg_gps_leap_second_t::stub (V4 API) or msg_gps_leap_second_t::stub + * (legacy API) before the maximum SBP message size is exceeded + */ +#define SBP_MSG_GPS_LEAP_SECOND_STUB_MAX 255u + +/** + * Encoded length of sbp_msg_gps_leap_second_t (V4 API) and + * msg_gps_leap_second_t (legacy API) + * + * This type is not fixed size and an instance of this message may be longer + * than the value indicated by this symbol. Users of the V4 API should call + * #sbp_msg_gps_leap_second_encoded_len to determine the actual size of an + * instance of this message. Users of the legacy API are required to track the + * encoded message length when interacting with the legacy type. + * + * See the documentation for libsbp for more details regarding the message + * structure and its variable length component(s) + */ +#define SBP_MSG_GPS_LEAP_SECOND_ENCODED_OVERHEAD 0u + +#define SBP_MSG_ITRF 0x0244 +/** + * The maximum number of items that can be stored in sbp_msg_itrf_t::stub (V4 + * API) or msg_itrf_t::stub (legacy API) before the maximum SBP message size is + * exceeded + */ +#define SBP_MSG_ITRF_STUB_MAX 255u + +/** + * Encoded length of sbp_msg_itrf_t (V4 API) and + * msg_itrf_t (legacy API) + * + * This type is not fixed size and an instance of this message may be longer + * than the value indicated by this symbol. Users of the V4 API should call + * #sbp_msg_itrf_encoded_len to determine the actual size of an instance + * of this message. Users of the legacy API are required to track the encoded + * message length when interacting with the legacy type. + * + * See the documentation for libsbp for more details regarding the message + * structure and its variable length component(s) + */ +#define SBP_MSG_ITRF_ENCODED_OVERHEAD 0u + #endif /* LIBSBP_NAVIGATION_MACROS_H */ diff --git a/c/include/libsbp/sbp_msg_type.h b/c/include/libsbp/sbp_msg_type.h index 297496588a..1be546c6e4 100644 --- a/c/include/libsbp/sbp_msg_type.h +++ b/c/include/libsbp/sbp_msg_type.h @@ -25,6 +25,7 @@ #include #include #include +#include #include #include #include @@ -126,6 +127,7 @@ typedef enum { SbpMsgGloBiases = SBP_MSG_GLO_BIASES, SbpMsgGnssCapb = SBP_MSG_GNSS_CAPB, SbpMsgGnssTimeOffset = SBP_MSG_GNSS_TIME_OFFSET, + SbpMsgGpsLeapSecond = SBP_MSG_GPS_LEAP_SECOND, SbpMsgGpsTimeDepA = SBP_MSG_GPS_TIME_DEP_A, SbpMsgGpsTimeGnss = SBP_MSG_GPS_TIME_GNSS, SbpMsgGpsTime = SBP_MSG_GPS_TIME, @@ -141,6 +143,7 @@ typedef enum { SbpMsgInsStatus = SBP_MSG_INS_STATUS, SbpMsgInsUpdates = SBP_MSG_INS_UPDATES, SbpMsgIono = SBP_MSG_IONO, + SbpMsgItrf = SBP_MSG_ITRF, SbpMsgLinuxCpuStateDepA = SBP_MSG_LINUX_CPU_STATE_DEP_A, SbpMsgLinuxCpuState = SBP_MSG_LINUX_CPU_STATE, SbpMsgLinuxMemStateDepA = SBP_MSG_LINUX_MEM_STATE_DEP_A, @@ -208,17 +211,30 @@ typedef enum { SbpMsgSpecanDep = SBP_MSG_SPECAN_DEP, SbpMsgSpecan = SBP_MSG_SPECAN, SbpMsgSsrCodeBiases = SBP_MSG_SSR_CODE_BIASES, + SbpMsgSsrCodePhaseBiasesBounds = SBP_MSG_SSR_CODE_PHASE_BIASES_BOUNDS, + SbpMsgSsrFlagHighLevel = SBP_MSG_SSR_FLAG_HIGH_LEVEL, + SbpMsgSsrFlagIonoGridPointSatLos = SBP_MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS, + SbpMsgSsrFlagIonoGridPoints = SBP_MSG_SSR_FLAG_IONO_GRID_POINTS, + SbpMsgSsrFlagIonoTileSatLos = SBP_MSG_SSR_FLAG_IONO_TILE_SAT_LOS, + SbpMsgSsrFlagSatellites = SBP_MSG_SSR_FLAG_SATELLITES, + SbpMsgSsrFlagTropoGridPoints = SBP_MSG_SSR_FLAG_TROPO_GRID_POINTS, SbpMsgSsrGridDefinitionDepA = SBP_MSG_SSR_GRID_DEFINITION_DEP_A, + SbpMsgSsrGriddedCorrectionBounds = SBP_MSG_SSR_GRIDDED_CORRECTION_BOUNDS, SbpMsgSsrGriddedCorrectionDepA = SBP_MSG_SSR_GRIDDED_CORRECTION_DEP_A, SbpMsgSsrGriddedCorrectionNoStdDepA = SBP_MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A, SbpMsgSsrGriddedCorrection = SBP_MSG_SSR_GRIDDED_CORRECTION, + SbpMsgSsrOrbitClockBoundsDegradation = + SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION, + SbpMsgSsrOrbitClockBounds = SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS, SbpMsgSsrOrbitClockDepA = SBP_MSG_SSR_ORBIT_CLOCK_DEP_A, SbpMsgSsrOrbitClock = SBP_MSG_SSR_ORBIT_CLOCK, SbpMsgSsrPhaseBiases = SBP_MSG_SSR_PHASE_BIASES, SbpMsgSsrSatelliteApc = SBP_MSG_SSR_SATELLITE_APC, SbpMsgSsrStecCorrectionDepA = SBP_MSG_SSR_STEC_CORRECTION_DEP_A, + SbpMsgSsrStecCorrectionDep = SBP_MSG_SSR_STEC_CORRECTION_DEP, SbpMsgSsrStecCorrection = SBP_MSG_SSR_STEC_CORRECTION, + SbpMsgSsrTileDefinitionDep = SBP_MSG_SSR_TILE_DEFINITION_DEP, SbpMsgSsrTileDefinition = SBP_MSG_SSR_TILE_DEFINITION, SbpMsgStartup = SBP_MSG_STARTUP, SbpMsgStatusJournal = SBP_MSG_STATUS_JOURNAL, diff --git a/c/include/libsbp/ssr_macros.h b/c/include/libsbp/ssr_macros.h index a3a86456d8..172471b93f 100644 --- a/c/include/libsbp/ssr_macros.h +++ b/c/include/libsbp/ssr_macros.h @@ -132,14 +132,38 @@ */ #define SBP_MSG_SSR_PHASE_BIASES_ENCODED_OVERHEAD 15u -#define SBP_MSG_SSR_STEC_CORRECTION 0x05FB +#define SBP_MSG_SSR_STEC_CORRECTION_DEP 0x05FB /** * The maximum number of items that can be stored in - * sbp_msg_ssr_stec_correction_t::stec_sat_list (V4 API) or - * msg_ssr_stec_correction_t::stec_sat_list (legacy API) before the maximum SBP - * message size is exceeded + * sbp_msg_ssr_stec_correction_dep_t::stec_sat_list (V4 API) or + * msg_ssr_stec_correction_dep_t::stec_sat_list (legacy API) before the maximum + * SBP message size is exceeded + */ +#define SBP_MSG_SSR_STEC_CORRECTION_DEP_STEC_SAT_LIST_MAX 21u + +/** + * Encoded length of sbp_msg_ssr_stec_correction_dep_t (V4 API) and + * msg_ssr_stec_correction_dep_t (legacy API) + * + * This type is not fixed size and an instance of this message may be longer + * than the value indicated by this symbol. Users of the V4 API should call + * #sbp_msg_ssr_stec_correction_dep_encoded_len to determine the actual size of + * an instance of this message. Users of the legacy API are required to track + * the encoded message length when interacting with the legacy type. + * + * See the documentation for libsbp for more details regarding the message + * structure and its variable length component(s) */ -#define SBP_MSG_SSR_STEC_CORRECTION_STEC_SAT_LIST_MAX 21u +#define SBP_MSG_SSR_STEC_CORRECTION_DEP_ENCODED_OVERHEAD 14u + +#define SBP_MSG_SSR_STEC_CORRECTION 0x05FD +/** + * The maximum number of items that can be stored in + * sbp_msg_ssr_stec_correction_t::stub (V4 API) or + * msg_ssr_stec_correction_t::stub (legacy API) before the maximum SBP message + * size is exceeded + */ +#define SBP_MSG_SSR_STEC_CORRECTION_STUB_MAX 255u /** * Encoded length of sbp_msg_ssr_stec_correction_t (V4 API) and @@ -154,7 +178,7 @@ * See the documentation for libsbp for more details regarding the message * structure and its variable length component(s) */ -#define SBP_MSG_SSR_STEC_CORRECTION_ENCODED_OVERHEAD 14u +#define SBP_MSG_SSR_STEC_CORRECTION_ENCODED_OVERHEAD 0u #define SBP_MSG_SSR_GRIDDED_CORRECTION 0x05FC /** @@ -180,12 +204,60 @@ */ #define SBP_MSG_SSR_GRIDDED_CORRECTION_ENCODED_OVERHEAD 23u -#define SBP_MSG_SSR_TILE_DEFINITION 0x05F6 +#define SBP_MSG_SSR_GRIDDED_CORRECTION_BOUNDS 0x05FE +/** + * The maximum number of items that can be stored in + * sbp_msg_ssr_gridded_correction_bounds_t::stub (V4 API) or + * msg_ssr_gridded_correction_bounds_t::stub (legacy API) before the maximum SBP + * message size is exceeded + */ +#define SBP_MSG_SSR_GRIDDED_CORRECTION_BOUNDS_STUB_MAX 255u + +/** + * Encoded length of sbp_msg_ssr_gridded_correction_bounds_t (V4 API) and + * msg_ssr_gridded_correction_bounds_t (legacy API) + * + * This type is not fixed size and an instance of this message may be longer + * than the value indicated by this symbol. Users of the V4 API should call + * #sbp_msg_ssr_gridded_correction_bounds_encoded_len to determine the actual + * size of an instance of this message. Users of the legacy API are required to + * track the encoded message length when interacting with the legacy type. + * + * See the documentation for libsbp for more details regarding the message + * structure and its variable length component(s) + */ +#define SBP_MSG_SSR_GRIDDED_CORRECTION_BOUNDS_ENCODED_OVERHEAD 0u + +#define SBP_MSG_SSR_TILE_DEFINITION_DEP 0x05F6 +/** + * Encoded length of sbp_msg_ssr_tile_definition_dep_t (V4 API) and + * msg_ssr_tile_definition_dep_t (legacy API) + */ +#define SBP_MSG_SSR_TILE_DEFINITION_DEP_ENCODED_LEN 24u + +#define SBP_MSG_SSR_TILE_DEFINITION 0x05F7 +/** + * The maximum number of items that can be stored in + * sbp_msg_ssr_tile_definition_t::stub (V4 API) or + * msg_ssr_tile_definition_t::stub (legacy API) before the maximum SBP message + * size is exceeded + */ +#define SBP_MSG_SSR_TILE_DEFINITION_STUB_MAX 255u + /** * Encoded length of sbp_msg_ssr_tile_definition_t (V4 API) and * msg_ssr_tile_definition_t (legacy API) + * + * This type is not fixed size and an instance of this message may be longer + * than the value indicated by this symbol. Users of the V4 API should call + * #sbp_msg_ssr_tile_definition_encoded_len to determine the actual size of an + * instance of this message. Users of the legacy API are required to track the + * encoded message length when interacting with the legacy type. + * + * See the documentation for libsbp for more details regarding the message + * structure and its variable length component(s) */ -#define SBP_MSG_SSR_TILE_DEFINITION_ENCODED_LEN 24u +#define SBP_MSG_SSR_TILE_DEFINITION_ENCODED_OVERHEAD 0u #define SBP_SATELLITEAPC_SATELLITE_TYPE_MASK (0x1fu) #define SBP_SATELLITEAPC_SATELLITE_TYPE_SHIFT (0u) @@ -385,4 +457,77 @@ */ #define SBP_MSG_SSR_GRID_DEFINITION_DEP_A_ENCODED_OVERHEAD 9u +#define SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS 0x05DE +/** + * The maximum number of items that can be stored in + * sbp_msg_ssr_orbit_clock_bounds_t::stub (V4 API) or + * msg_ssr_orbit_clock_bounds_t::stub (legacy API) before the maximum SBP + * message size is exceeded + */ +#define SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS_STUB_MAX 255u + +/** + * Encoded length of sbp_msg_ssr_orbit_clock_bounds_t (V4 API) and + * msg_ssr_orbit_clock_bounds_t (legacy API) + * + * This type is not fixed size and an instance of this message may be longer + * than the value indicated by this symbol. Users of the V4 API should call + * #sbp_msg_ssr_orbit_clock_bounds_encoded_len to determine the actual size of + * an instance of this message. Users of the legacy API are required to track + * the encoded message length when interacting with the legacy type. + * + * See the documentation for libsbp for more details regarding the message + * structure and its variable length component(s) + */ +#define SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS_ENCODED_OVERHEAD 0u + +#define SBP_MSG_SSR_CODE_PHASE_BIASES_BOUNDS 0x05EC +/** + * The maximum number of items that can be stored in + * sbp_msg_ssr_code_phase_biases_bounds_t::stub (V4 API) or + * msg_ssr_code_phase_biases_bounds_t::stub (legacy API) before the maximum SBP + * message size is exceeded + */ +#define SBP_MSG_SSR_CODE_PHASE_BIASES_BOUNDS_STUB_MAX 255u + +/** + * Encoded length of sbp_msg_ssr_code_phase_biases_bounds_t (V4 API) and + * msg_ssr_code_phase_biases_bounds_t (legacy API) + * + * This type is not fixed size and an instance of this message may be longer + * than the value indicated by this symbol. Users of the V4 API should call + * #sbp_msg_ssr_code_phase_biases_bounds_encoded_len to determine the actual + * size of an instance of this message. Users of the legacy API are required to + * track the encoded message length when interacting with the legacy type. + * + * See the documentation for libsbp for more details regarding the message + * structure and its variable length component(s) + */ +#define SBP_MSG_SSR_CODE_PHASE_BIASES_BOUNDS_ENCODED_OVERHEAD 0u + +#define SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION 0x05DF +/** + * The maximum number of items that can be stored in + * sbp_msg_ssr_orbit_clock_bounds_degradation_t::stub (V4 API) or + * msg_ssr_orbit_clock_bounds_degradation_t::stub (legacy API) before the + * maximum SBP message size is exceeded + */ +#define SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION_STUB_MAX 255u + +/** + * Encoded length of sbp_msg_ssr_orbit_clock_bounds_degradation_t (V4 API) and + * msg_ssr_orbit_clock_bounds_degradation_t (legacy API) + * + * This type is not fixed size and an instance of this message may be longer + * than the value indicated by this symbol. Users of the V4 API should call + * #sbp_msg_ssr_orbit_clock_bounds_degradation_encoded_len to determine the + * actual size of an instance of this message. Users of the legacy API are + * required to track the encoded message length when interacting with the legacy + * type. + * + * See the documentation for libsbp for more details regarding the message + * structure and its variable length component(s) + */ +#define SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION_ENCODED_OVERHEAD 0u + #endif /* LIBSBP_SSR_MACROS_H */ diff --git a/c/include/libsbp/v4/integrity.h b/c/include/libsbp/v4/integrity.h new file mode 100644 index 0000000000..71576464b1 --- /dev/null +++ b/c/include/libsbp/v4/integrity.h @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/integrity.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_V4_INTEGRITY_MESSAGES_H +#define LIBSBP_V4_INTEGRITY_MESSAGES_H +#include +#include +#include +#include +#include +#include + +#endif /* LIBSBP_V4_INTEGRITY_MESSAGES_H */ diff --git a/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h b/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h new file mode 100644 index 0000000000..9ee327f9cb --- /dev/null +++ b/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h @@ -0,0 +1,184 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/integrity.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_HIGH_LEVEL_H +#define LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_HIGH_LEVEL_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_SSR_FLAG_HIGH_LEVEL + * + *****************************************************************************/ +typedef struct { + u8 stub[SBP_MSG_SSR_FLAG_HIGH_LEVEL_STUB_MAX]; + /** + * Number of elements in stub + * + * When sending a message fill in this field with the number elements set in + * stub before calling an appropriate libsbp send function + * + * When receiving a message query this field for the number of elements in + * stub. The value of any elements beyond the index specified in this field is + * undefined + */ + u8 n_stub; +} sbp_msg_ssr_flag_high_level_t; + +/** + * Get encoded size of an instance of sbp_msg_ssr_flag_high_level_t + * + * @param msg sbp_msg_ssr_flag_high_level_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_ssr_flag_high_level_encoded_len( + const sbp_msg_ssr_flag_high_level_t *msg) { + return SBP_MSG_SSR_FLAG_HIGH_LEVEL_ENCODED_OVERHEAD + + (msg->n_stub * SBP_ENCODED_LEN_U8); +} + +/** + * Encode an instance of sbp_msg_ssr_flag_high_level_t to wire representation + * + * This function encodes the given instance in to the user provided buffer. The + * buffer provided to this function must be large enough to store the encoded + * message otherwise it will return SBP_ENCODE_ERROR without writing anything to + * the buffer. + * + * Specify the length of the destination buffer in the \p len parameter. If + * non-null the number of bytes written to the buffer will be returned in \p + * n_written. + * + * @param buf Destination buffer + * @param len Length of \p buf + * @param n_written If not null, on success will be set to the number of bytes + * written to \p buf + * @param msg Instance of sbp_msg_ssr_flag_high_level_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_high_level_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_high_level_t *msg); + +/** + * Decode an instance of sbp_msg_ssr_flag_high_level_t from wire representation + * + * This function decodes the wire representation of a + * sbp_msg_ssr_flag_high_level_t message to the given instance. The caller must + * specify the length of the buffer in the \p len parameter. If non-null the + * number of bytes read from the buffer will be returned in \p n_read. + * + * @param buf Wire representation of the sbp_msg_ssr_flag_high_level_t instance + * @param len Length of \p buf + * @param n_read If not null, on success will be set to the number of bytes read + * from \p buf + * @param msg Destination + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_high_level_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_high_level_t *msg); +/** + * Send an instance of sbp_msg_ssr_flag_high_level_t with the given write + * function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_ssr_flag_high_level_t + * + * The given message will be encoded to wire representation and passed in to the + * given write function callback. The write callback will be called several + * times for each invocation of this function. + * + * @param s SBP state + * @param sender_id SBP sender id + * @param msg Message to send + * @param write Write function + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_high_level_send( + sbp_state_t *s, u16 sender_id, const sbp_msg_ssr_flag_high_level_t *msg, + sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_ssr_flag_high_level_t + * + * The two instances will be compared and a value returned consistent with the + * return codes of comparison functions from the C standard library + * + * 0 will be returned if \p a and \p b are considered equal + * A value less than 0 will be returned if \p a is considered to be less than \p + * b A value greater than 0 will be returned if \p b is considered to be greater + * than \p b + * + * @param a sbp_msg_ssr_flag_high_level_t instance + * @param b sbp_msg_ssr_flag_high_level_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_ssr_flag_high_level_cmp( + const sbp_msg_ssr_flag_high_level_t *a, + const sbp_msg_ssr_flag_high_level_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==(const sbp_msg_ssr_flag_high_level_t &lhs, + const sbp_msg_ssr_flag_high_level_t &rhs) { + return sbp_msg_ssr_flag_high_level_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=(const sbp_msg_ssr_flag_high_level_t &lhs, + const sbp_msg_ssr_flag_high_level_t &rhs) { + return sbp_msg_ssr_flag_high_level_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<(const sbp_msg_ssr_flag_high_level_t &lhs, + const sbp_msg_ssr_flag_high_level_t &rhs) { + return sbp_msg_ssr_flag_high_level_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=(const sbp_msg_ssr_flag_high_level_t &lhs, + const sbp_msg_ssr_flag_high_level_t &rhs) { + return sbp_msg_ssr_flag_high_level_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>(const sbp_msg_ssr_flag_high_level_t &lhs, + const sbp_msg_ssr_flag_high_level_t &rhs) { + return sbp_msg_ssr_flag_high_level_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=(const sbp_msg_ssr_flag_high_level_t &lhs, + const sbp_msg_ssr_flag_high_level_t &rhs) { + return sbp_msg_ssr_flag_high_level_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_HIGH_LEVEL_H */ diff --git a/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_IONO_GRID_POINTS.h b/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_IONO_GRID_POINTS.h new file mode 100644 index 0000000000..1e36115ef9 --- /dev/null +++ b/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_IONO_GRID_POINTS.h @@ -0,0 +1,187 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/integrity.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_IONO_GRID_POINTS_H +#define LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_IONO_GRID_POINTS_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_SSR_FLAG_IONO_GRID_POINTS + * + *****************************************************************************/ +typedef struct { + u8 stub[SBP_MSG_SSR_FLAG_IONO_GRID_POINTS_STUB_MAX]; + /** + * Number of elements in stub + * + * When sending a message fill in this field with the number elements set in + * stub before calling an appropriate libsbp send function + * + * When receiving a message query this field for the number of elements in + * stub. The value of any elements beyond the index specified in this field is + * undefined + */ + u8 n_stub; +} sbp_msg_ssr_flag_iono_grid_points_t; + +/** + * Get encoded size of an instance of sbp_msg_ssr_flag_iono_grid_points_t + * + * @param msg sbp_msg_ssr_flag_iono_grid_points_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_ssr_flag_iono_grid_points_encoded_len( + const sbp_msg_ssr_flag_iono_grid_points_t *msg) { + return SBP_MSG_SSR_FLAG_IONO_GRID_POINTS_ENCODED_OVERHEAD + + (msg->n_stub * SBP_ENCODED_LEN_U8); +} + +/** + * Encode an instance of sbp_msg_ssr_flag_iono_grid_points_t to wire + * representation + * + * This function encodes the given instance in to the user provided buffer. The + * buffer provided to this function must be large enough to store the encoded + * message otherwise it will return SBP_ENCODE_ERROR without writing anything to + * the buffer. + * + * Specify the length of the destination buffer in the \p len parameter. If + * non-null the number of bytes written to the buffer will be returned in \p + * n_written. + * + * @param buf Destination buffer + * @param len Length of \p buf + * @param n_written If not null, on success will be set to the number of bytes + * written to \p buf + * @param msg Instance of sbp_msg_ssr_flag_iono_grid_points_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_iono_grid_points_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_iono_grid_points_t *msg); + +/** + * Decode an instance of sbp_msg_ssr_flag_iono_grid_points_t from wire + * representation + * + * This function decodes the wire representation of a + * sbp_msg_ssr_flag_iono_grid_points_t message to the given instance. The caller + * must specify the length of the buffer in the \p len parameter. If non-null + * the number of bytes read from the buffer will be returned in \p n_read. + * + * @param buf Wire representation of the sbp_msg_ssr_flag_iono_grid_points_t + * instance + * @param len Length of \p buf + * @param n_read If not null, on success will be set to the number of bytes read + * from \p buf + * @param msg Destination + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_iono_grid_points_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_iono_grid_points_t *msg); +/** + * Send an instance of sbp_msg_ssr_flag_iono_grid_points_t with the given write + * function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_ssr_flag_iono_grid_points_t + * + * The given message will be encoded to wire representation and passed in to the + * given write function callback. The write callback will be called several + * times for each invocation of this function. + * + * @param s SBP state + * @param sender_id SBP sender id + * @param msg Message to send + * @param write Write function + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_iono_grid_points_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_flag_iono_grid_points_t *msg, sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_ssr_flag_iono_grid_points_t + * + * The two instances will be compared and a value returned consistent with the + * return codes of comparison functions from the C standard library + * + * 0 will be returned if \p a and \p b are considered equal + * A value less than 0 will be returned if \p a is considered to be less than \p + * b A value greater than 0 will be returned if \p b is considered to be greater + * than \p b + * + * @param a sbp_msg_ssr_flag_iono_grid_points_t instance + * @param b sbp_msg_ssr_flag_iono_grid_points_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_ssr_flag_iono_grid_points_cmp( + const sbp_msg_ssr_flag_iono_grid_points_t *a, + const sbp_msg_ssr_flag_iono_grid_points_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==(const sbp_msg_ssr_flag_iono_grid_points_t &lhs, + const sbp_msg_ssr_flag_iono_grid_points_t &rhs) { + return sbp_msg_ssr_flag_iono_grid_points_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=(const sbp_msg_ssr_flag_iono_grid_points_t &lhs, + const sbp_msg_ssr_flag_iono_grid_points_t &rhs) { + return sbp_msg_ssr_flag_iono_grid_points_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<(const sbp_msg_ssr_flag_iono_grid_points_t &lhs, + const sbp_msg_ssr_flag_iono_grid_points_t &rhs) { + return sbp_msg_ssr_flag_iono_grid_points_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=(const sbp_msg_ssr_flag_iono_grid_points_t &lhs, + const sbp_msg_ssr_flag_iono_grid_points_t &rhs) { + return sbp_msg_ssr_flag_iono_grid_points_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>(const sbp_msg_ssr_flag_iono_grid_points_t &lhs, + const sbp_msg_ssr_flag_iono_grid_points_t &rhs) { + return sbp_msg_ssr_flag_iono_grid_points_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=(const sbp_msg_ssr_flag_iono_grid_points_t &lhs, + const sbp_msg_ssr_flag_iono_grid_points_t &rhs) { + return sbp_msg_ssr_flag_iono_grid_points_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_IONO_GRID_POINTS_H */ diff --git a/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS.h b/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS.h new file mode 100644 index 0000000000..e233b0dcff --- /dev/null +++ b/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS.h @@ -0,0 +1,195 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/integrity.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS_H +#define LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS + * + *****************************************************************************/ +typedef struct { + u8 stub[SBP_MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS_STUB_MAX]; + /** + * Number of elements in stub + * + * When sending a message fill in this field with the number elements set in + * stub before calling an appropriate libsbp send function + * + * When receiving a message query this field for the number of elements in + * stub. The value of any elements beyond the index specified in this field is + * undefined + */ + u8 n_stub; +} sbp_msg_ssr_flag_iono_grid_point_sat_los_t; + +/** + * Get encoded size of an instance of sbp_msg_ssr_flag_iono_grid_point_sat_los_t + * + * @param msg sbp_msg_ssr_flag_iono_grid_point_sat_los_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_ssr_flag_iono_grid_point_sat_los_encoded_len( + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t *msg) { + return SBP_MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS_ENCODED_OVERHEAD + + (msg->n_stub * SBP_ENCODED_LEN_U8); +} + +/** + * Encode an instance of sbp_msg_ssr_flag_iono_grid_point_sat_los_t to wire + * representation + * + * This function encodes the given instance in to the user provided buffer. The + * buffer provided to this function must be large enough to store the encoded + * message otherwise it will return SBP_ENCODE_ERROR without writing anything to + * the buffer. + * + * Specify the length of the destination buffer in the \p len parameter. If + * non-null the number of bytes written to the buffer will be returned in \p + * n_written. + * + * @param buf Destination buffer + * @param len Length of \p buf + * @param n_written If not null, on success will be set to the number of bytes + * written to \p buf + * @param msg Instance of sbp_msg_ssr_flag_iono_grid_point_sat_los_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_iono_grid_point_sat_los_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t *msg); + +/** + * Decode an instance of sbp_msg_ssr_flag_iono_grid_point_sat_los_t from wire + * representation + * + * This function decodes the wire representation of a + * sbp_msg_ssr_flag_iono_grid_point_sat_los_t message to the given instance. The + * caller must specify the length of the buffer in the \p len parameter. If + * non-null the number of bytes read from the buffer will be returned in \p + * n_read. + * + * @param buf Wire representation of the + * sbp_msg_ssr_flag_iono_grid_point_sat_los_t instance + * @param len Length of \p buf + * @param n_read If not null, on success will be set to the number of bytes read + * from \p buf + * @param msg Destination + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_iono_grid_point_sat_los_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_iono_grid_point_sat_los_t *msg); +/** + * Send an instance of sbp_msg_ssr_flag_iono_grid_point_sat_los_t with the given + * write function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_ssr_flag_iono_grid_point_sat_los_t + * + * The given message will be encoded to wire representation and passed in to the + * given write function callback. The write callback will be called several + * times for each invocation of this function. + * + * @param s SBP state + * @param sender_id SBP sender id + * @param msg Message to send + * @param write Write function + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_iono_grid_point_sat_los_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t *msg, + sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_ssr_flag_iono_grid_point_sat_los_t + * + * The two instances will be compared and a value returned consistent with the + * return codes of comparison functions from the C standard library + * + * 0 will be returned if \p a and \p b are considered equal + * A value less than 0 will be returned if \p a is considered to be less than \p + * b A value greater than 0 will be returned if \p b is considered to be greater + * than \p b + * + * @param a sbp_msg_ssr_flag_iono_grid_point_sat_los_t instance + * @param b sbp_msg_ssr_flag_iono_grid_point_sat_los_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_ssr_flag_iono_grid_point_sat_los_cmp( + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t *a, + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==( + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &lhs, + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &rhs) { + return sbp_msg_ssr_flag_iono_grid_point_sat_los_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=( + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &lhs, + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &rhs) { + return sbp_msg_ssr_flag_iono_grid_point_sat_los_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<( + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &lhs, + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &rhs) { + return sbp_msg_ssr_flag_iono_grid_point_sat_los_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=( + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &lhs, + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &rhs) { + return sbp_msg_ssr_flag_iono_grid_point_sat_los_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>( + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &lhs, + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &rhs) { + return sbp_msg_ssr_flag_iono_grid_point_sat_los_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=( + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &lhs, + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &rhs) { + return sbp_msg_ssr_flag_iono_grid_point_sat_los_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS_H */ diff --git a/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_IONO_TILE_SAT_LOS.h b/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_IONO_TILE_SAT_LOS.h new file mode 100644 index 0000000000..7424224c75 --- /dev/null +++ b/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_IONO_TILE_SAT_LOS.h @@ -0,0 +1,188 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/integrity.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_IONO_TILE_SAT_LOS_H +#define LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_IONO_TILE_SAT_LOS_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_SSR_FLAG_IONO_TILE_SAT_LOS + * + *****************************************************************************/ +typedef struct { + u8 stub[SBP_MSG_SSR_FLAG_IONO_TILE_SAT_LOS_STUB_MAX]; + /** + * Number of elements in stub + * + * When sending a message fill in this field with the number elements set in + * stub before calling an appropriate libsbp send function + * + * When receiving a message query this field for the number of elements in + * stub. The value of any elements beyond the index specified in this field is + * undefined + */ + u8 n_stub; +} sbp_msg_ssr_flag_iono_tile_sat_los_t; + +/** + * Get encoded size of an instance of sbp_msg_ssr_flag_iono_tile_sat_los_t + * + * @param msg sbp_msg_ssr_flag_iono_tile_sat_los_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_ssr_flag_iono_tile_sat_los_encoded_len( + const sbp_msg_ssr_flag_iono_tile_sat_los_t *msg) { + return SBP_MSG_SSR_FLAG_IONO_TILE_SAT_LOS_ENCODED_OVERHEAD + + (msg->n_stub * SBP_ENCODED_LEN_U8); +} + +/** + * Encode an instance of sbp_msg_ssr_flag_iono_tile_sat_los_t to wire + * representation + * + * This function encodes the given instance in to the user provided buffer. The + * buffer provided to this function must be large enough to store the encoded + * message otherwise it will return SBP_ENCODE_ERROR without writing anything to + * the buffer. + * + * Specify the length of the destination buffer in the \p len parameter. If + * non-null the number of bytes written to the buffer will be returned in \p + * n_written. + * + * @param buf Destination buffer + * @param len Length of \p buf + * @param n_written If not null, on success will be set to the number of bytes + * written to \p buf + * @param msg Instance of sbp_msg_ssr_flag_iono_tile_sat_los_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_iono_tile_sat_los_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_iono_tile_sat_los_t *msg); + +/** + * Decode an instance of sbp_msg_ssr_flag_iono_tile_sat_los_t from wire + * representation + * + * This function decodes the wire representation of a + * sbp_msg_ssr_flag_iono_tile_sat_los_t message to the given instance. The + * caller must specify the length of the buffer in the \p len parameter. If + * non-null the number of bytes read from the buffer will be returned in \p + * n_read. + * + * @param buf Wire representation of the sbp_msg_ssr_flag_iono_tile_sat_los_t + * instance + * @param len Length of \p buf + * @param n_read If not null, on success will be set to the number of bytes read + * from \p buf + * @param msg Destination + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_iono_tile_sat_los_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_iono_tile_sat_los_t *msg); +/** + * Send an instance of sbp_msg_ssr_flag_iono_tile_sat_los_t with the given write + * function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_ssr_flag_iono_tile_sat_los_t + * + * The given message will be encoded to wire representation and passed in to the + * given write function callback. The write callback will be called several + * times for each invocation of this function. + * + * @param s SBP state + * @param sender_id SBP sender id + * @param msg Message to send + * @param write Write function + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_iono_tile_sat_los_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_flag_iono_tile_sat_los_t *msg, sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_ssr_flag_iono_tile_sat_los_t + * + * The two instances will be compared and a value returned consistent with the + * return codes of comparison functions from the C standard library + * + * 0 will be returned if \p a and \p b are considered equal + * A value less than 0 will be returned if \p a is considered to be less than \p + * b A value greater than 0 will be returned if \p b is considered to be greater + * than \p b + * + * @param a sbp_msg_ssr_flag_iono_tile_sat_los_t instance + * @param b sbp_msg_ssr_flag_iono_tile_sat_los_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_ssr_flag_iono_tile_sat_los_cmp( + const sbp_msg_ssr_flag_iono_tile_sat_los_t *a, + const sbp_msg_ssr_flag_iono_tile_sat_los_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==(const sbp_msg_ssr_flag_iono_tile_sat_los_t &lhs, + const sbp_msg_ssr_flag_iono_tile_sat_los_t &rhs) { + return sbp_msg_ssr_flag_iono_tile_sat_los_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=(const sbp_msg_ssr_flag_iono_tile_sat_los_t &lhs, + const sbp_msg_ssr_flag_iono_tile_sat_los_t &rhs) { + return sbp_msg_ssr_flag_iono_tile_sat_los_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<(const sbp_msg_ssr_flag_iono_tile_sat_los_t &lhs, + const sbp_msg_ssr_flag_iono_tile_sat_los_t &rhs) { + return sbp_msg_ssr_flag_iono_tile_sat_los_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=(const sbp_msg_ssr_flag_iono_tile_sat_los_t &lhs, + const sbp_msg_ssr_flag_iono_tile_sat_los_t &rhs) { + return sbp_msg_ssr_flag_iono_tile_sat_los_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>(const sbp_msg_ssr_flag_iono_tile_sat_los_t &lhs, + const sbp_msg_ssr_flag_iono_tile_sat_los_t &rhs) { + return sbp_msg_ssr_flag_iono_tile_sat_los_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=(const sbp_msg_ssr_flag_iono_tile_sat_los_t &lhs, + const sbp_msg_ssr_flag_iono_tile_sat_los_t &rhs) { + return sbp_msg_ssr_flag_iono_tile_sat_los_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_IONO_TILE_SAT_LOS_H */ diff --git a/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_SATELLITES.h b/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_SATELLITES.h new file mode 100644 index 0000000000..f4144a4c80 --- /dev/null +++ b/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_SATELLITES.h @@ -0,0 +1,184 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/integrity.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_SATELLITES_H +#define LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_SATELLITES_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_SSR_FLAG_SATELLITES + * + *****************************************************************************/ +typedef struct { + u8 stub[SBP_MSG_SSR_FLAG_SATELLITES_STUB_MAX]; + /** + * Number of elements in stub + * + * When sending a message fill in this field with the number elements set in + * stub before calling an appropriate libsbp send function + * + * When receiving a message query this field for the number of elements in + * stub. The value of any elements beyond the index specified in this field is + * undefined + */ + u8 n_stub; +} sbp_msg_ssr_flag_satellites_t; + +/** + * Get encoded size of an instance of sbp_msg_ssr_flag_satellites_t + * + * @param msg sbp_msg_ssr_flag_satellites_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_ssr_flag_satellites_encoded_len( + const sbp_msg_ssr_flag_satellites_t *msg) { + return SBP_MSG_SSR_FLAG_SATELLITES_ENCODED_OVERHEAD + + (msg->n_stub * SBP_ENCODED_LEN_U8); +} + +/** + * Encode an instance of sbp_msg_ssr_flag_satellites_t to wire representation + * + * This function encodes the given instance in to the user provided buffer. The + * buffer provided to this function must be large enough to store the encoded + * message otherwise it will return SBP_ENCODE_ERROR without writing anything to + * the buffer. + * + * Specify the length of the destination buffer in the \p len parameter. If + * non-null the number of bytes written to the buffer will be returned in \p + * n_written. + * + * @param buf Destination buffer + * @param len Length of \p buf + * @param n_written If not null, on success will be set to the number of bytes + * written to \p buf + * @param msg Instance of sbp_msg_ssr_flag_satellites_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_satellites_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_satellites_t *msg); + +/** + * Decode an instance of sbp_msg_ssr_flag_satellites_t from wire representation + * + * This function decodes the wire representation of a + * sbp_msg_ssr_flag_satellites_t message to the given instance. The caller must + * specify the length of the buffer in the \p len parameter. If non-null the + * number of bytes read from the buffer will be returned in \p n_read. + * + * @param buf Wire representation of the sbp_msg_ssr_flag_satellites_t instance + * @param len Length of \p buf + * @param n_read If not null, on success will be set to the number of bytes read + * from \p buf + * @param msg Destination + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_satellites_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_satellites_t *msg); +/** + * Send an instance of sbp_msg_ssr_flag_satellites_t with the given write + * function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_ssr_flag_satellites_t + * + * The given message will be encoded to wire representation and passed in to the + * given write function callback. The write callback will be called several + * times for each invocation of this function. + * + * @param s SBP state + * @param sender_id SBP sender id + * @param msg Message to send + * @param write Write function + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_satellites_send( + sbp_state_t *s, u16 sender_id, const sbp_msg_ssr_flag_satellites_t *msg, + sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_ssr_flag_satellites_t + * + * The two instances will be compared and a value returned consistent with the + * return codes of comparison functions from the C standard library + * + * 0 will be returned if \p a and \p b are considered equal + * A value less than 0 will be returned if \p a is considered to be less than \p + * b A value greater than 0 will be returned if \p b is considered to be greater + * than \p b + * + * @param a sbp_msg_ssr_flag_satellites_t instance + * @param b sbp_msg_ssr_flag_satellites_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_ssr_flag_satellites_cmp( + const sbp_msg_ssr_flag_satellites_t *a, + const sbp_msg_ssr_flag_satellites_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==(const sbp_msg_ssr_flag_satellites_t &lhs, + const sbp_msg_ssr_flag_satellites_t &rhs) { + return sbp_msg_ssr_flag_satellites_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=(const sbp_msg_ssr_flag_satellites_t &lhs, + const sbp_msg_ssr_flag_satellites_t &rhs) { + return sbp_msg_ssr_flag_satellites_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<(const sbp_msg_ssr_flag_satellites_t &lhs, + const sbp_msg_ssr_flag_satellites_t &rhs) { + return sbp_msg_ssr_flag_satellites_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=(const sbp_msg_ssr_flag_satellites_t &lhs, + const sbp_msg_ssr_flag_satellites_t &rhs) { + return sbp_msg_ssr_flag_satellites_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>(const sbp_msg_ssr_flag_satellites_t &lhs, + const sbp_msg_ssr_flag_satellites_t &rhs) { + return sbp_msg_ssr_flag_satellites_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=(const sbp_msg_ssr_flag_satellites_t &lhs, + const sbp_msg_ssr_flag_satellites_t &rhs) { + return sbp_msg_ssr_flag_satellites_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_SATELLITES_H */ diff --git a/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_TROPO_GRID_POINTS.h b/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_TROPO_GRID_POINTS.h new file mode 100644 index 0000000000..e2cc205f24 --- /dev/null +++ b/c/include/libsbp/v4/integrity/MSG_SSR_FLAG_TROPO_GRID_POINTS.h @@ -0,0 +1,188 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/integrity.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_TROPO_GRID_POINTS_H +#define LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_TROPO_GRID_POINTS_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_SSR_FLAG_TROPO_GRID_POINTS + * + *****************************************************************************/ +typedef struct { + u8 stub[SBP_MSG_SSR_FLAG_TROPO_GRID_POINTS_STUB_MAX]; + /** + * Number of elements in stub + * + * When sending a message fill in this field with the number elements set in + * stub before calling an appropriate libsbp send function + * + * When receiving a message query this field for the number of elements in + * stub. The value of any elements beyond the index specified in this field is + * undefined + */ + u8 n_stub; +} sbp_msg_ssr_flag_tropo_grid_points_t; + +/** + * Get encoded size of an instance of sbp_msg_ssr_flag_tropo_grid_points_t + * + * @param msg sbp_msg_ssr_flag_tropo_grid_points_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_ssr_flag_tropo_grid_points_encoded_len( + const sbp_msg_ssr_flag_tropo_grid_points_t *msg) { + return SBP_MSG_SSR_FLAG_TROPO_GRID_POINTS_ENCODED_OVERHEAD + + (msg->n_stub * SBP_ENCODED_LEN_U8); +} + +/** + * Encode an instance of sbp_msg_ssr_flag_tropo_grid_points_t to wire + * representation + * + * This function encodes the given instance in to the user provided buffer. The + * buffer provided to this function must be large enough to store the encoded + * message otherwise it will return SBP_ENCODE_ERROR without writing anything to + * the buffer. + * + * Specify the length of the destination buffer in the \p len parameter. If + * non-null the number of bytes written to the buffer will be returned in \p + * n_written. + * + * @param buf Destination buffer + * @param len Length of \p buf + * @param n_written If not null, on success will be set to the number of bytes + * written to \p buf + * @param msg Instance of sbp_msg_ssr_flag_tropo_grid_points_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_tropo_grid_points_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_tropo_grid_points_t *msg); + +/** + * Decode an instance of sbp_msg_ssr_flag_tropo_grid_points_t from wire + * representation + * + * This function decodes the wire representation of a + * sbp_msg_ssr_flag_tropo_grid_points_t message to the given instance. The + * caller must specify the length of the buffer in the \p len parameter. If + * non-null the number of bytes read from the buffer will be returned in \p + * n_read. + * + * @param buf Wire representation of the sbp_msg_ssr_flag_tropo_grid_points_t + * instance + * @param len Length of \p buf + * @param n_read If not null, on success will be set to the number of bytes read + * from \p buf + * @param msg Destination + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_tropo_grid_points_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_tropo_grid_points_t *msg); +/** + * Send an instance of sbp_msg_ssr_flag_tropo_grid_points_t with the given write + * function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_ssr_flag_tropo_grid_points_t + * + * The given message will be encoded to wire representation and passed in to the + * given write function callback. The write callback will be called several + * times for each invocation of this function. + * + * @param s SBP state + * @param sender_id SBP sender id + * @param msg Message to send + * @param write Write function + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_tropo_grid_points_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_flag_tropo_grid_points_t *msg, sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_ssr_flag_tropo_grid_points_t + * + * The two instances will be compared and a value returned consistent with the + * return codes of comparison functions from the C standard library + * + * 0 will be returned if \p a and \p b are considered equal + * A value less than 0 will be returned if \p a is considered to be less than \p + * b A value greater than 0 will be returned if \p b is considered to be greater + * than \p b + * + * @param a sbp_msg_ssr_flag_tropo_grid_points_t instance + * @param b sbp_msg_ssr_flag_tropo_grid_points_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_ssr_flag_tropo_grid_points_cmp( + const sbp_msg_ssr_flag_tropo_grid_points_t *a, + const sbp_msg_ssr_flag_tropo_grid_points_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==(const sbp_msg_ssr_flag_tropo_grid_points_t &lhs, + const sbp_msg_ssr_flag_tropo_grid_points_t &rhs) { + return sbp_msg_ssr_flag_tropo_grid_points_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=(const sbp_msg_ssr_flag_tropo_grid_points_t &lhs, + const sbp_msg_ssr_flag_tropo_grid_points_t &rhs) { + return sbp_msg_ssr_flag_tropo_grid_points_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<(const sbp_msg_ssr_flag_tropo_grid_points_t &lhs, + const sbp_msg_ssr_flag_tropo_grid_points_t &rhs) { + return sbp_msg_ssr_flag_tropo_grid_points_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=(const sbp_msg_ssr_flag_tropo_grid_points_t &lhs, + const sbp_msg_ssr_flag_tropo_grid_points_t &rhs) { + return sbp_msg_ssr_flag_tropo_grid_points_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>(const sbp_msg_ssr_flag_tropo_grid_points_t &lhs, + const sbp_msg_ssr_flag_tropo_grid_points_t &rhs) { + return sbp_msg_ssr_flag_tropo_grid_points_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=(const sbp_msg_ssr_flag_tropo_grid_points_t &lhs, + const sbp_msg_ssr_flag_tropo_grid_points_t &rhs) { + return sbp_msg_ssr_flag_tropo_grid_points_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_V4_INTEGRITY_MSG_SSR_FLAG_TROPO_GRID_POINTS_H */ diff --git a/c/include/libsbp/v4/navigation.h b/c/include/libsbp/v4/navigation.h index ae2060d7ca..f61fd07640 100644 --- a/c/include/libsbp/v4/navigation.h +++ b/c/include/libsbp/v4/navigation.h @@ -26,9 +26,11 @@ #include #include #include +#include #include #include #include +#include #include #include #include diff --git a/c/include/libsbp/v4/navigation/MSG_GPS_LEAP_SECOND.h b/c/include/libsbp/v4/navigation/MSG_GPS_LEAP_SECOND.h new file mode 100644 index 0000000000..d896a2e0a9 --- /dev/null +++ b/c/include/libsbp/v4/navigation/MSG_GPS_LEAP_SECOND.h @@ -0,0 +1,188 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/navigation.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_V4_NAVIGATION_MSG_GPS_LEAP_SECOND_H +#define LIBSBP_V4_NAVIGATION_MSG_GPS_LEAP_SECOND_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_GPS_LEAP_SECOND + * + *****************************************************************************/ +/** Leap second SBP message. + + * +* Emulates the GPS CNAV message, reserving bytes for future broadcast of the +drift model parameters. + */ +typedef struct { + u8 stub[SBP_MSG_GPS_LEAP_SECOND_STUB_MAX]; + /** + * Number of elements in stub + * + * When sending a message fill in this field with the number elements set in + * stub before calling an appropriate libsbp send function + * + * When receiving a message query this field for the number of elements in + * stub. The value of any elements beyond the index specified in this field is + * undefined + */ + u8 n_stub; +} sbp_msg_gps_leap_second_t; + +/** + * Get encoded size of an instance of sbp_msg_gps_leap_second_t + * + * @param msg sbp_msg_gps_leap_second_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_gps_leap_second_encoded_len( + const sbp_msg_gps_leap_second_t *msg) { + return SBP_MSG_GPS_LEAP_SECOND_ENCODED_OVERHEAD + + (msg->n_stub * SBP_ENCODED_LEN_U8); +} + +/** + * Encode an instance of sbp_msg_gps_leap_second_t to wire representation + * + * This function encodes the given instance in to the user provided buffer. The + * buffer provided to this function must be large enough to store the encoded + * message otherwise it will return SBP_ENCODE_ERROR without writing anything to + * the buffer. + * + * Specify the length of the destination buffer in the \p len parameter. If + * non-null the number of bytes written to the buffer will be returned in \p + * n_written. + * + * @param buf Destination buffer + * @param len Length of \p buf + * @param n_written If not null, on success will be set to the number of bytes + * written to \p buf + * @param msg Instance of sbp_msg_gps_leap_second_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 +sbp_msg_gps_leap_second_encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_gps_leap_second_t *msg); + +/** + * Decode an instance of sbp_msg_gps_leap_second_t from wire representation + * + * This function decodes the wire representation of a sbp_msg_gps_leap_second_t + * message to the given instance. The caller must specify the length of the + * buffer in the \p len parameter. If non-null the number of bytes read from the + * buffer will be returned in \p n_read. + * + * @param buf Wire representation of the sbp_msg_gps_leap_second_t instance + * @param len Length of \p buf + * @param n_read If not null, on success will be set to the number of bytes read + * from \p buf + * @param msg Destination + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_gps_leap_second_decode(const uint8_t *buf, uint8_t len, + uint8_t *n_read, + sbp_msg_gps_leap_second_t *msg); +/** + * Send an instance of sbp_msg_gps_leap_second_t with the given write function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_gps_leap_second_t + * + * The given message will be encoded to wire representation and passed in to the + * given write function callback. The write callback will be called several + * times for each invocation of this function. + * + * @param s SBP state + * @param sender_id SBP sender id + * @param msg Message to send + * @param write Write function + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_gps_leap_second_send(sbp_state_t *s, u16 sender_id, + const sbp_msg_gps_leap_second_t *msg, + sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_gps_leap_second_t + * + * The two instances will be compared and a value returned consistent with the + * return codes of comparison functions from the C standard library + * + * 0 will be returned if \p a and \p b are considered equal + * A value less than 0 will be returned if \p a is considered to be less than \p + * b A value greater than 0 will be returned if \p b is considered to be greater + * than \p b + * + * @param a sbp_msg_gps_leap_second_t instance + * @param b sbp_msg_gps_leap_second_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_gps_leap_second_cmp(const sbp_msg_gps_leap_second_t *a, + const sbp_msg_gps_leap_second_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==(const sbp_msg_gps_leap_second_t &lhs, + const sbp_msg_gps_leap_second_t &rhs) { + return sbp_msg_gps_leap_second_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=(const sbp_msg_gps_leap_second_t &lhs, + const sbp_msg_gps_leap_second_t &rhs) { + return sbp_msg_gps_leap_second_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<(const sbp_msg_gps_leap_second_t &lhs, + const sbp_msg_gps_leap_second_t &rhs) { + return sbp_msg_gps_leap_second_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=(const sbp_msg_gps_leap_second_t &lhs, + const sbp_msg_gps_leap_second_t &rhs) { + return sbp_msg_gps_leap_second_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>(const sbp_msg_gps_leap_second_t &lhs, + const sbp_msg_gps_leap_second_t &rhs) { + return sbp_msg_gps_leap_second_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=(const sbp_msg_gps_leap_second_t &lhs, + const sbp_msg_gps_leap_second_t &rhs) { + return sbp_msg_gps_leap_second_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_V4_NAVIGATION_MSG_GPS_LEAP_SECOND_H */ diff --git a/c/include/libsbp/v4/navigation/MSG_ITRF.h b/c/include/libsbp/v4/navigation/MSG_ITRF.h new file mode 100644 index 0000000000..eb0e377f0b --- /dev/null +++ b/c/include/libsbp/v4/navigation/MSG_ITRF.h @@ -0,0 +1,178 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/navigation.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_V4_NAVIGATION_MSG_ITRF_H +#define LIBSBP_V4_NAVIGATION_MSG_ITRF_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_ITRF + * + *****************************************************************************/ +typedef struct { + u8 stub[SBP_MSG_ITRF_STUB_MAX]; + /** + * Number of elements in stub + * + * When sending a message fill in this field with the number elements set in + * stub before calling an appropriate libsbp send function + * + * When receiving a message query this field for the number of elements in + * stub. The value of any elements beyond the index specified in this field is + * undefined + */ + u8 n_stub; +} sbp_msg_itrf_t; + +/** + * Get encoded size of an instance of sbp_msg_itrf_t + * + * @param msg sbp_msg_itrf_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_itrf_encoded_len(const sbp_msg_itrf_t *msg) { + return SBP_MSG_ITRF_ENCODED_OVERHEAD + (msg->n_stub * SBP_ENCODED_LEN_U8); +} + +/** + * Encode an instance of sbp_msg_itrf_t to wire representation + * + * This function encodes the given instance in to the user provided buffer. The + * buffer provided to this function must be large enough to store the encoded + * message otherwise it will return SBP_ENCODE_ERROR without writing anything to + * the buffer. + * + * Specify the length of the destination buffer in the \p len parameter. If + * non-null the number of bytes written to the buffer will be returned in \p + * n_written. + * + * @param buf Destination buffer + * @param len Length of \p buf + * @param n_written If not null, on success will be set to the number of bytes + * written to \p buf + * @param msg Instance of sbp_msg_itrf_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_itrf_encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_itrf_t *msg); + +/** + * Decode an instance of sbp_msg_itrf_t from wire representation + * + * This function decodes the wire representation of a sbp_msg_itrf_t message to + * the given instance. The caller must specify the length of the buffer in the + * \p len parameter. If non-null the number of bytes read from the buffer will + * be returned in \p n_read. + * + * @param buf Wire representation of the sbp_msg_itrf_t instance + * @param len Length of \p buf + * @param n_read If not null, on success will be set to the number of bytes read + * from \p buf + * @param msg Destination + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_itrf_decode(const uint8_t *buf, uint8_t len, + uint8_t *n_read, sbp_msg_itrf_t *msg); +/** + * Send an instance of sbp_msg_itrf_t with the given write function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_itrf_t + * + * The given message will be encoded to wire representation and passed in to the + * given write function callback. The write callback will be called several + * times for each invocation of this function. + * + * @param s SBP state + * @param sender_id SBP sender id + * @param msg Message to send + * @param write Write function + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_itrf_send(sbp_state_t *s, u16 sender_id, + const sbp_msg_itrf_t *msg, + sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_itrf_t + * + * The two instances will be compared and a value returned consistent with the + * return codes of comparison functions from the C standard library + * + * 0 will be returned if \p a and \p b are considered equal + * A value less than 0 will be returned if \p a is considered to be less than \p + * b A value greater than 0 will be returned if \p b is considered to be greater + * than \p b + * + * @param a sbp_msg_itrf_t instance + * @param b sbp_msg_itrf_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_itrf_cmp(const sbp_msg_itrf_t *a, + const sbp_msg_itrf_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==(const sbp_msg_itrf_t &lhs, + const sbp_msg_itrf_t &rhs) { + return sbp_msg_itrf_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=(const sbp_msg_itrf_t &lhs, + const sbp_msg_itrf_t &rhs) { + return sbp_msg_itrf_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<(const sbp_msg_itrf_t &lhs, + const sbp_msg_itrf_t &rhs) { + return sbp_msg_itrf_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=(const sbp_msg_itrf_t &lhs, + const sbp_msg_itrf_t &rhs) { + return sbp_msg_itrf_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>(const sbp_msg_itrf_t &lhs, + const sbp_msg_itrf_t &rhs) { + return sbp_msg_itrf_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=(const sbp_msg_itrf_t &lhs, + const sbp_msg_itrf_t &rhs) { + return sbp_msg_itrf_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_V4_NAVIGATION_MSG_ITRF_H */ diff --git a/c/include/libsbp/v4/sbp_msg.h b/c/include/libsbp/v4/sbp_msg.h index 9959cfdc83..f8428fbbc1 100644 --- a/c/include/libsbp/v4/sbp_msg.h +++ b/c/include/libsbp/v4/sbp_msg.h @@ -30,6 +30,7 @@ #include #include #include +#include #include #include #include @@ -132,6 +133,7 @@ typedef union { sbp_msg_glo_biases_t glo_biases; sbp_msg_gnss_capb_t gnss_capb; sbp_msg_gnss_time_offset_t gnss_time_offset; + sbp_msg_gps_leap_second_t gps_leap_second; sbp_msg_gps_time_dep_a_t gps_time_dep_a; sbp_msg_gps_time_gnss_t gps_time_gnss; sbp_msg_gps_time_t gps_time; @@ -147,6 +149,7 @@ typedef union { sbp_msg_ins_status_t ins_status; sbp_msg_ins_updates_t ins_updates; sbp_msg_iono_t iono; + sbp_msg_itrf_t itrf; sbp_msg_linux_cpu_state_dep_a_t linux_cpu_state_dep_a; sbp_msg_linux_cpu_state_t linux_cpu_state; sbp_msg_linux_mem_state_dep_a_t linux_mem_state_dep_a; @@ -214,17 +217,30 @@ typedef union { sbp_msg_specan_dep_t specan_dep; sbp_msg_specan_t specan; sbp_msg_ssr_code_biases_t ssr_code_biases; + sbp_msg_ssr_code_phase_biases_bounds_t ssr_code_phase_biases_bounds; + sbp_msg_ssr_flag_high_level_t ssr_flag_high_level; + sbp_msg_ssr_flag_iono_grid_point_sat_los_t ssr_flag_iono_grid_point_sat_los; + sbp_msg_ssr_flag_iono_grid_points_t ssr_flag_iono_grid_points; + sbp_msg_ssr_flag_iono_tile_sat_los_t ssr_flag_iono_tile_sat_los; + sbp_msg_ssr_flag_satellites_t ssr_flag_satellites; + sbp_msg_ssr_flag_tropo_grid_points_t ssr_flag_tropo_grid_points; sbp_msg_ssr_grid_definition_dep_a_t ssr_grid_definition_dep_a; + sbp_msg_ssr_gridded_correction_bounds_t ssr_gridded_correction_bounds; sbp_msg_ssr_gridded_correction_dep_a_t ssr_gridded_correction_dep_a; sbp_msg_ssr_gridded_correction_no_std_dep_a_t ssr_gridded_correction_no_std_dep_a; sbp_msg_ssr_gridded_correction_t ssr_gridded_correction; + sbp_msg_ssr_orbit_clock_bounds_degradation_t + ssr_orbit_clock_bounds_degradation; + sbp_msg_ssr_orbit_clock_bounds_t ssr_orbit_clock_bounds; sbp_msg_ssr_orbit_clock_dep_a_t ssr_orbit_clock_dep_a; sbp_msg_ssr_orbit_clock_t ssr_orbit_clock; sbp_msg_ssr_phase_biases_t ssr_phase_biases; sbp_msg_ssr_satellite_apc_t ssr_satellite_apc; sbp_msg_ssr_stec_correction_dep_a_t ssr_stec_correction_dep_a; + sbp_msg_ssr_stec_correction_dep_t ssr_stec_correction_dep; sbp_msg_ssr_stec_correction_t ssr_stec_correction; + sbp_msg_ssr_tile_definition_dep_t ssr_tile_definition_dep; sbp_msg_ssr_tile_definition_t ssr_tile_definition; sbp_msg_startup_t startup; sbp_msg_status_journal_t status_journal; @@ -493,6 +509,9 @@ static inline s8 sbp_message_encode(uint8_t *buf, uint8_t len, case SbpMsgGnssTimeOffset: return sbp_msg_gnss_time_offset_encode(buf, len, n_written, &msg->gnss_time_offset); + case SbpMsgGpsLeapSecond: + return sbp_msg_gps_leap_second_encode(buf, len, n_written, + &msg->gps_leap_second); case SbpMsgGpsTimeDepA: return sbp_msg_gps_time_dep_a_encode(buf, len, n_written, &msg->gps_time_dep_a); @@ -528,6 +547,8 @@ static inline s8 sbp_message_encode(uint8_t *buf, uint8_t len, return sbp_msg_ins_updates_encode(buf, len, n_written, &msg->ins_updates); case SbpMsgIono: return sbp_msg_iono_encode(buf, len, n_written, &msg->iono); + case SbpMsgItrf: + return sbp_msg_itrf_encode(buf, len, n_written, &msg->itrf); case SbpMsgLinuxCpuStateDepA: return sbp_msg_linux_cpu_state_dep_a_encode(buf, len, n_written, &msg->linux_cpu_state_dep_a); @@ -706,9 +727,33 @@ static inline s8 sbp_message_encode(uint8_t *buf, uint8_t len, case SbpMsgSsrCodeBiases: return sbp_msg_ssr_code_biases_encode(buf, len, n_written, &msg->ssr_code_biases); + case SbpMsgSsrCodePhaseBiasesBounds: + return sbp_msg_ssr_code_phase_biases_bounds_encode( + buf, len, n_written, &msg->ssr_code_phase_biases_bounds); + case SbpMsgSsrFlagHighLevel: + return sbp_msg_ssr_flag_high_level_encode(buf, len, n_written, + &msg->ssr_flag_high_level); + case SbpMsgSsrFlagIonoGridPointSatLos: + return sbp_msg_ssr_flag_iono_grid_point_sat_los_encode( + buf, len, n_written, &msg->ssr_flag_iono_grid_point_sat_los); + case SbpMsgSsrFlagIonoGridPoints: + return sbp_msg_ssr_flag_iono_grid_points_encode( + buf, len, n_written, &msg->ssr_flag_iono_grid_points); + case SbpMsgSsrFlagIonoTileSatLos: + return sbp_msg_ssr_flag_iono_tile_sat_los_encode( + buf, len, n_written, &msg->ssr_flag_iono_tile_sat_los); + case SbpMsgSsrFlagSatellites: + return sbp_msg_ssr_flag_satellites_encode(buf, len, n_written, + &msg->ssr_flag_satellites); + case SbpMsgSsrFlagTropoGridPoints: + return sbp_msg_ssr_flag_tropo_grid_points_encode( + buf, len, n_written, &msg->ssr_flag_tropo_grid_points); case SbpMsgSsrGridDefinitionDepA: return sbp_msg_ssr_grid_definition_dep_a_encode( buf, len, n_written, &msg->ssr_grid_definition_dep_a); + case SbpMsgSsrGriddedCorrectionBounds: + return sbp_msg_ssr_gridded_correction_bounds_encode( + buf, len, n_written, &msg->ssr_gridded_correction_bounds); case SbpMsgSsrGriddedCorrectionDepA: return sbp_msg_ssr_gridded_correction_dep_a_encode( buf, len, n_written, &msg->ssr_gridded_correction_dep_a); @@ -718,6 +763,12 @@ static inline s8 sbp_message_encode(uint8_t *buf, uint8_t len, case SbpMsgSsrGriddedCorrection: return sbp_msg_ssr_gridded_correction_encode( buf, len, n_written, &msg->ssr_gridded_correction); + case SbpMsgSsrOrbitClockBoundsDegradation: + return sbp_msg_ssr_orbit_clock_bounds_degradation_encode( + buf, len, n_written, &msg->ssr_orbit_clock_bounds_degradation); + case SbpMsgSsrOrbitClockBounds: + return sbp_msg_ssr_orbit_clock_bounds_encode( + buf, len, n_written, &msg->ssr_orbit_clock_bounds); case SbpMsgSsrOrbitClockDepA: return sbp_msg_ssr_orbit_clock_dep_a_encode(buf, len, n_written, &msg->ssr_orbit_clock_dep_a); @@ -733,9 +784,15 @@ static inline s8 sbp_message_encode(uint8_t *buf, uint8_t len, case SbpMsgSsrStecCorrectionDepA: return sbp_msg_ssr_stec_correction_dep_a_encode( buf, len, n_written, &msg->ssr_stec_correction_dep_a); + case SbpMsgSsrStecCorrectionDep: + return sbp_msg_ssr_stec_correction_dep_encode( + buf, len, n_written, &msg->ssr_stec_correction_dep); case SbpMsgSsrStecCorrection: return sbp_msg_ssr_stec_correction_encode(buf, len, n_written, &msg->ssr_stec_correction); + case SbpMsgSsrTileDefinitionDep: + return sbp_msg_ssr_tile_definition_dep_encode( + buf, len, n_written, &msg->ssr_tile_definition_dep); case SbpMsgSsrTileDefinition: return sbp_msg_ssr_tile_definition_encode(buf, len, n_written, &msg->ssr_tile_definition); @@ -1066,6 +1123,9 @@ static inline s8 sbp_message_decode(const uint8_t *buf, uint8_t len, case SbpMsgGnssTimeOffset: return sbp_msg_gnss_time_offset_decode(buf, len, n_read, &msg->gnss_time_offset); + case SbpMsgGpsLeapSecond: + return sbp_msg_gps_leap_second_decode(buf, len, n_read, + &msg->gps_leap_second); case SbpMsgGpsTimeDepA: return sbp_msg_gps_time_dep_a_decode(buf, len, n_read, &msg->gps_time_dep_a); @@ -1101,6 +1161,8 @@ static inline s8 sbp_message_decode(const uint8_t *buf, uint8_t len, return sbp_msg_ins_updates_decode(buf, len, n_read, &msg->ins_updates); case SbpMsgIono: return sbp_msg_iono_decode(buf, len, n_read, &msg->iono); + case SbpMsgItrf: + return sbp_msg_itrf_decode(buf, len, n_read, &msg->itrf); case SbpMsgLinuxCpuStateDepA: return sbp_msg_linux_cpu_state_dep_a_decode(buf, len, n_read, &msg->linux_cpu_state_dep_a); @@ -1276,9 +1338,33 @@ static inline s8 sbp_message_decode(const uint8_t *buf, uint8_t len, case SbpMsgSsrCodeBiases: return sbp_msg_ssr_code_biases_decode(buf, len, n_read, &msg->ssr_code_biases); + case SbpMsgSsrCodePhaseBiasesBounds: + return sbp_msg_ssr_code_phase_biases_bounds_decode( + buf, len, n_read, &msg->ssr_code_phase_biases_bounds); + case SbpMsgSsrFlagHighLevel: + return sbp_msg_ssr_flag_high_level_decode(buf, len, n_read, + &msg->ssr_flag_high_level); + case SbpMsgSsrFlagIonoGridPointSatLos: + return sbp_msg_ssr_flag_iono_grid_point_sat_los_decode( + buf, len, n_read, &msg->ssr_flag_iono_grid_point_sat_los); + case SbpMsgSsrFlagIonoGridPoints: + return sbp_msg_ssr_flag_iono_grid_points_decode( + buf, len, n_read, &msg->ssr_flag_iono_grid_points); + case SbpMsgSsrFlagIonoTileSatLos: + return sbp_msg_ssr_flag_iono_tile_sat_los_decode( + buf, len, n_read, &msg->ssr_flag_iono_tile_sat_los); + case SbpMsgSsrFlagSatellites: + return sbp_msg_ssr_flag_satellites_decode(buf, len, n_read, + &msg->ssr_flag_satellites); + case SbpMsgSsrFlagTropoGridPoints: + return sbp_msg_ssr_flag_tropo_grid_points_decode( + buf, len, n_read, &msg->ssr_flag_tropo_grid_points); case SbpMsgSsrGridDefinitionDepA: return sbp_msg_ssr_grid_definition_dep_a_decode( buf, len, n_read, &msg->ssr_grid_definition_dep_a); + case SbpMsgSsrGriddedCorrectionBounds: + return sbp_msg_ssr_gridded_correction_bounds_decode( + buf, len, n_read, &msg->ssr_gridded_correction_bounds); case SbpMsgSsrGriddedCorrectionDepA: return sbp_msg_ssr_gridded_correction_dep_a_decode( buf, len, n_read, &msg->ssr_gridded_correction_dep_a); @@ -1288,6 +1374,12 @@ static inline s8 sbp_message_decode(const uint8_t *buf, uint8_t len, case SbpMsgSsrGriddedCorrection: return sbp_msg_ssr_gridded_correction_decode( buf, len, n_read, &msg->ssr_gridded_correction); + case SbpMsgSsrOrbitClockBoundsDegradation: + return sbp_msg_ssr_orbit_clock_bounds_degradation_decode( + buf, len, n_read, &msg->ssr_orbit_clock_bounds_degradation); + case SbpMsgSsrOrbitClockBounds: + return sbp_msg_ssr_orbit_clock_bounds_decode( + buf, len, n_read, &msg->ssr_orbit_clock_bounds); case SbpMsgSsrOrbitClockDepA: return sbp_msg_ssr_orbit_clock_dep_a_decode(buf, len, n_read, &msg->ssr_orbit_clock_dep_a); @@ -1303,9 +1395,15 @@ static inline s8 sbp_message_decode(const uint8_t *buf, uint8_t len, case SbpMsgSsrStecCorrectionDepA: return sbp_msg_ssr_stec_correction_dep_a_decode( buf, len, n_read, &msg->ssr_stec_correction_dep_a); + case SbpMsgSsrStecCorrectionDep: + return sbp_msg_ssr_stec_correction_dep_decode( + buf, len, n_read, &msg->ssr_stec_correction_dep); case SbpMsgSsrStecCorrection: return sbp_msg_ssr_stec_correction_decode(buf, len, n_read, &msg->ssr_stec_correction); + case SbpMsgSsrTileDefinitionDep: + return sbp_msg_ssr_tile_definition_dep_decode( + buf, len, n_read, &msg->ssr_tile_definition_dep); case SbpMsgSsrTileDefinition: return sbp_msg_ssr_tile_definition_decode(buf, len, n_read, &msg->ssr_tile_definition); @@ -1581,6 +1679,8 @@ static inline size_t sbp_message_encoded_len(sbp_msg_type_t msg_type, return sbp_msg_gnss_capb_encoded_len(&msg->gnss_capb); case SbpMsgGnssTimeOffset: return sbp_msg_gnss_time_offset_encoded_len(&msg->gnss_time_offset); + case SbpMsgGpsLeapSecond: + return sbp_msg_gps_leap_second_encoded_len(&msg->gps_leap_second); case SbpMsgGpsTimeDepA: return sbp_msg_gps_time_dep_a_encoded_len(&msg->gps_time_dep_a); case SbpMsgGpsTimeGnss: @@ -1611,6 +1711,8 @@ static inline size_t sbp_message_encoded_len(sbp_msg_type_t msg_type, return sbp_msg_ins_updates_encoded_len(&msg->ins_updates); case SbpMsgIono: return sbp_msg_iono_encoded_len(&msg->iono); + case SbpMsgItrf: + return sbp_msg_itrf_encoded_len(&msg->itrf); case SbpMsgLinuxCpuStateDepA: return sbp_msg_linux_cpu_state_dep_a_encoded_len( &msg->linux_cpu_state_dep_a); @@ -1759,9 +1861,31 @@ static inline size_t sbp_message_encoded_len(sbp_msg_type_t msg_type, return sbp_msg_specan_encoded_len(&msg->specan); case SbpMsgSsrCodeBiases: return sbp_msg_ssr_code_biases_encoded_len(&msg->ssr_code_biases); + case SbpMsgSsrCodePhaseBiasesBounds: + return sbp_msg_ssr_code_phase_biases_bounds_encoded_len( + &msg->ssr_code_phase_biases_bounds); + case SbpMsgSsrFlagHighLevel: + return sbp_msg_ssr_flag_high_level_encoded_len(&msg->ssr_flag_high_level); + case SbpMsgSsrFlagIonoGridPointSatLos: + return sbp_msg_ssr_flag_iono_grid_point_sat_los_encoded_len( + &msg->ssr_flag_iono_grid_point_sat_los); + case SbpMsgSsrFlagIonoGridPoints: + return sbp_msg_ssr_flag_iono_grid_points_encoded_len( + &msg->ssr_flag_iono_grid_points); + case SbpMsgSsrFlagIonoTileSatLos: + return sbp_msg_ssr_flag_iono_tile_sat_los_encoded_len( + &msg->ssr_flag_iono_tile_sat_los); + case SbpMsgSsrFlagSatellites: + return sbp_msg_ssr_flag_satellites_encoded_len(&msg->ssr_flag_satellites); + case SbpMsgSsrFlagTropoGridPoints: + return sbp_msg_ssr_flag_tropo_grid_points_encoded_len( + &msg->ssr_flag_tropo_grid_points); case SbpMsgSsrGridDefinitionDepA: return sbp_msg_ssr_grid_definition_dep_a_encoded_len( &msg->ssr_grid_definition_dep_a); + case SbpMsgSsrGriddedCorrectionBounds: + return sbp_msg_ssr_gridded_correction_bounds_encoded_len( + &msg->ssr_gridded_correction_bounds); case SbpMsgSsrGriddedCorrectionDepA: return sbp_msg_ssr_gridded_correction_dep_a_encoded_len( &msg->ssr_gridded_correction_dep_a); @@ -1771,6 +1895,12 @@ static inline size_t sbp_message_encoded_len(sbp_msg_type_t msg_type, case SbpMsgSsrGriddedCorrection: return sbp_msg_ssr_gridded_correction_encoded_len( &msg->ssr_gridded_correction); + case SbpMsgSsrOrbitClockBoundsDegradation: + return sbp_msg_ssr_orbit_clock_bounds_degradation_encoded_len( + &msg->ssr_orbit_clock_bounds_degradation); + case SbpMsgSsrOrbitClockBounds: + return sbp_msg_ssr_orbit_clock_bounds_encoded_len( + &msg->ssr_orbit_clock_bounds); case SbpMsgSsrOrbitClockDepA: return sbp_msg_ssr_orbit_clock_dep_a_encoded_len( &msg->ssr_orbit_clock_dep_a); @@ -1783,8 +1913,14 @@ static inline size_t sbp_message_encoded_len(sbp_msg_type_t msg_type, case SbpMsgSsrStecCorrectionDepA: return sbp_msg_ssr_stec_correction_dep_a_encoded_len( &msg->ssr_stec_correction_dep_a); + case SbpMsgSsrStecCorrectionDep: + return sbp_msg_ssr_stec_correction_dep_encoded_len( + &msg->ssr_stec_correction_dep); case SbpMsgSsrStecCorrection: return sbp_msg_ssr_stec_correction_encoded_len(&msg->ssr_stec_correction); + case SbpMsgSsrTileDefinitionDep: + return sbp_msg_ssr_tile_definition_dep_encoded_len( + &msg->ssr_tile_definition_dep); case SbpMsgSsrTileDefinition: return sbp_msg_ssr_tile_definition_encoded_len(&msg->ssr_tile_definition); case SbpMsgStartup: @@ -2078,6 +2214,9 @@ static inline int sbp_message_cmp(sbp_msg_type_t msg_type, const sbp_msg_t *a, case SbpMsgGnssTimeOffset: return sbp_msg_gnss_time_offset_cmp(&a->gnss_time_offset, &b->gnss_time_offset); + case SbpMsgGpsLeapSecond: + return sbp_msg_gps_leap_second_cmp(&a->gps_leap_second, + &b->gps_leap_second); case SbpMsgGpsTimeDepA: return sbp_msg_gps_time_dep_a_cmp(&a->gps_time_dep_a, &b->gps_time_dep_a); case SbpMsgGpsTimeGnss: @@ -2110,6 +2249,8 @@ static inline int sbp_message_cmp(sbp_msg_type_t msg_type, const sbp_msg_t *a, return sbp_msg_ins_updates_cmp(&a->ins_updates, &b->ins_updates); case SbpMsgIono: return sbp_msg_iono_cmp(&a->iono, &b->iono); + case SbpMsgItrf: + return sbp_msg_itrf_cmp(&a->itrf, &b->itrf); case SbpMsgLinuxCpuStateDepA: return sbp_msg_linux_cpu_state_dep_a_cmp(&a->linux_cpu_state_dep_a, &b->linux_cpu_state_dep_a); @@ -2278,9 +2419,34 @@ static inline int sbp_message_cmp(sbp_msg_type_t msg_type, const sbp_msg_t *a, case SbpMsgSsrCodeBiases: return sbp_msg_ssr_code_biases_cmp(&a->ssr_code_biases, &b->ssr_code_biases); + case SbpMsgSsrCodePhaseBiasesBounds: + return sbp_msg_ssr_code_phase_biases_bounds_cmp( + &a->ssr_code_phase_biases_bounds, &b->ssr_code_phase_biases_bounds); + case SbpMsgSsrFlagHighLevel: + return sbp_msg_ssr_flag_high_level_cmp(&a->ssr_flag_high_level, + &b->ssr_flag_high_level); + case SbpMsgSsrFlagIonoGridPointSatLos: + return sbp_msg_ssr_flag_iono_grid_point_sat_los_cmp( + &a->ssr_flag_iono_grid_point_sat_los, + &b->ssr_flag_iono_grid_point_sat_los); + case SbpMsgSsrFlagIonoGridPoints: + return sbp_msg_ssr_flag_iono_grid_points_cmp( + &a->ssr_flag_iono_grid_points, &b->ssr_flag_iono_grid_points); + case SbpMsgSsrFlagIonoTileSatLos: + return sbp_msg_ssr_flag_iono_tile_sat_los_cmp( + &a->ssr_flag_iono_tile_sat_los, &b->ssr_flag_iono_tile_sat_los); + case SbpMsgSsrFlagSatellites: + return sbp_msg_ssr_flag_satellites_cmp(&a->ssr_flag_satellites, + &b->ssr_flag_satellites); + case SbpMsgSsrFlagTropoGridPoints: + return sbp_msg_ssr_flag_tropo_grid_points_cmp( + &a->ssr_flag_tropo_grid_points, &b->ssr_flag_tropo_grid_points); case SbpMsgSsrGridDefinitionDepA: return sbp_msg_ssr_grid_definition_dep_a_cmp( &a->ssr_grid_definition_dep_a, &b->ssr_grid_definition_dep_a); + case SbpMsgSsrGriddedCorrectionBounds: + return sbp_msg_ssr_gridded_correction_bounds_cmp( + &a->ssr_gridded_correction_bounds, &b->ssr_gridded_correction_bounds); case SbpMsgSsrGriddedCorrectionDepA: return sbp_msg_ssr_gridded_correction_dep_a_cmp( &a->ssr_gridded_correction_dep_a, &b->ssr_gridded_correction_dep_a); @@ -2291,6 +2457,13 @@ static inline int sbp_message_cmp(sbp_msg_type_t msg_type, const sbp_msg_t *a, case SbpMsgSsrGriddedCorrection: return sbp_msg_ssr_gridded_correction_cmp(&a->ssr_gridded_correction, &b->ssr_gridded_correction); + case SbpMsgSsrOrbitClockBoundsDegradation: + return sbp_msg_ssr_orbit_clock_bounds_degradation_cmp( + &a->ssr_orbit_clock_bounds_degradation, + &b->ssr_orbit_clock_bounds_degradation); + case SbpMsgSsrOrbitClockBounds: + return sbp_msg_ssr_orbit_clock_bounds_cmp(&a->ssr_orbit_clock_bounds, + &b->ssr_orbit_clock_bounds); case SbpMsgSsrOrbitClockDepA: return sbp_msg_ssr_orbit_clock_dep_a_cmp(&a->ssr_orbit_clock_dep_a, &b->ssr_orbit_clock_dep_a); @@ -2306,9 +2479,15 @@ static inline int sbp_message_cmp(sbp_msg_type_t msg_type, const sbp_msg_t *a, case SbpMsgSsrStecCorrectionDepA: return sbp_msg_ssr_stec_correction_dep_a_cmp( &a->ssr_stec_correction_dep_a, &b->ssr_stec_correction_dep_a); + case SbpMsgSsrStecCorrectionDep: + return sbp_msg_ssr_stec_correction_dep_cmp(&a->ssr_stec_correction_dep, + &b->ssr_stec_correction_dep); case SbpMsgSsrStecCorrection: return sbp_msg_ssr_stec_correction_cmp(&a->ssr_stec_correction, &b->ssr_stec_correction); + case SbpMsgSsrTileDefinitionDep: + return sbp_msg_ssr_tile_definition_dep_cmp(&a->ssr_tile_definition_dep, + &b->ssr_tile_definition_dep); case SbpMsgSsrTileDefinition: return sbp_msg_ssr_tile_definition_cmp(&a->ssr_tile_definition, &b->ssr_tile_definition); diff --git a/c/include/libsbp/v4/ssr.h b/c/include/libsbp/v4/ssr.h index b2b87956f6..37f0cc25e4 100644 --- a/c/include/libsbp/v4/ssr.h +++ b/c/include/libsbp/v4/ssr.h @@ -22,17 +22,23 @@ #include #include #include +#include #include +#include #include #include #include #include +#include +#include #include #include #include #include +#include #include #include +#include #include #include #include diff --git a/c/include/libsbp/v4/ssr/MSG_SSR_CODE_PHASE_BIASES_BOUNDS.h b/c/include/libsbp/v4/ssr/MSG_SSR_CODE_PHASE_BIASES_BOUNDS.h new file mode 100644 index 0000000000..aeab349b5a --- /dev/null +++ b/c/include/libsbp/v4/ssr/MSG_SSR_CODE_PHASE_BIASES_BOUNDS.h @@ -0,0 +1,194 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/ssr.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_V4_SSR_MSG_SSR_CODE_PHASE_BIASES_BOUNDS_H +#define LIBSBP_V4_SSR_MSG_SSR_CODE_PHASE_BIASES_BOUNDS_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_SSR_CODE_PHASE_BIASES_BOUNDS + * + *****************************************************************************/ +typedef struct { + u8 stub[SBP_MSG_SSR_CODE_PHASE_BIASES_BOUNDS_STUB_MAX]; + /** + * Number of elements in stub + * + * When sending a message fill in this field with the number elements set in + * stub before calling an appropriate libsbp send function + * + * When receiving a message query this field for the number of elements in + * stub. The value of any elements beyond the index specified in this field is + * undefined + */ + u8 n_stub; +} sbp_msg_ssr_code_phase_biases_bounds_t; + +/** + * Get encoded size of an instance of sbp_msg_ssr_code_phase_biases_bounds_t + * + * @param msg sbp_msg_ssr_code_phase_biases_bounds_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_ssr_code_phase_biases_bounds_encoded_len( + const sbp_msg_ssr_code_phase_biases_bounds_t *msg) { + return SBP_MSG_SSR_CODE_PHASE_BIASES_BOUNDS_ENCODED_OVERHEAD + + (msg->n_stub * SBP_ENCODED_LEN_U8); +} + +/** + * Encode an instance of sbp_msg_ssr_code_phase_biases_bounds_t to wire + * representation + * + * This function encodes the given instance in to the user provided buffer. The + * buffer provided to this function must be large enough to store the encoded + * message otherwise it will return SBP_ENCODE_ERROR without writing anything to + * the buffer. + * + * Specify the length of the destination buffer in the \p len parameter. If + * non-null the number of bytes written to the buffer will be returned in \p + * n_written. + * + * @param buf Destination buffer + * @param len Length of \p buf + * @param n_written If not null, on success will be set to the number of bytes + * written to \p buf + * @param msg Instance of sbp_msg_ssr_code_phase_biases_bounds_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_code_phase_biases_bounds_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_code_phase_biases_bounds_t *msg); + +/** + * Decode an instance of sbp_msg_ssr_code_phase_biases_bounds_t from wire + * representation + * + * This function decodes the wire representation of a + * sbp_msg_ssr_code_phase_biases_bounds_t message to the given instance. The + * caller must specify the length of the buffer in the \p len parameter. If + * non-null the number of bytes read from the buffer will be returned in \p + * n_read. + * + * @param buf Wire representation of the sbp_msg_ssr_code_phase_biases_bounds_t + * instance + * @param len Length of \p buf + * @param n_read If not null, on success will be set to the number of bytes read + * from \p buf + * @param msg Destination + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_code_phase_biases_bounds_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_code_phase_biases_bounds_t *msg); +/** + * Send an instance of sbp_msg_ssr_code_phase_biases_bounds_t with the given + * write function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_ssr_code_phase_biases_bounds_t + * + * The given message will be encoded to wire representation and passed in to the + * given write function callback. The write callback will be called several + * times for each invocation of this function. + * + * @param s SBP state + * @param sender_id SBP sender id + * @param msg Message to send + * @param write Write function + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_code_phase_biases_bounds_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_code_phase_biases_bounds_t *msg, sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_ssr_code_phase_biases_bounds_t + * + * The two instances will be compared and a value returned consistent with the + * return codes of comparison functions from the C standard library + * + * 0 will be returned if \p a and \p b are considered equal + * A value less than 0 will be returned if \p a is considered to be less than \p + * b A value greater than 0 will be returned if \p b is considered to be greater + * than \p b + * + * @param a sbp_msg_ssr_code_phase_biases_bounds_t instance + * @param b sbp_msg_ssr_code_phase_biases_bounds_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_ssr_code_phase_biases_bounds_cmp( + const sbp_msg_ssr_code_phase_biases_bounds_t *a, + const sbp_msg_ssr_code_phase_biases_bounds_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==( + const sbp_msg_ssr_code_phase_biases_bounds_t &lhs, + const sbp_msg_ssr_code_phase_biases_bounds_t &rhs) { + return sbp_msg_ssr_code_phase_biases_bounds_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=( + const sbp_msg_ssr_code_phase_biases_bounds_t &lhs, + const sbp_msg_ssr_code_phase_biases_bounds_t &rhs) { + return sbp_msg_ssr_code_phase_biases_bounds_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<( + const sbp_msg_ssr_code_phase_biases_bounds_t &lhs, + const sbp_msg_ssr_code_phase_biases_bounds_t &rhs) { + return sbp_msg_ssr_code_phase_biases_bounds_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=( + const sbp_msg_ssr_code_phase_biases_bounds_t &lhs, + const sbp_msg_ssr_code_phase_biases_bounds_t &rhs) { + return sbp_msg_ssr_code_phase_biases_bounds_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>( + const sbp_msg_ssr_code_phase_biases_bounds_t &lhs, + const sbp_msg_ssr_code_phase_biases_bounds_t &rhs) { + return sbp_msg_ssr_code_phase_biases_bounds_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=( + const sbp_msg_ssr_code_phase_biases_bounds_t &lhs, + const sbp_msg_ssr_code_phase_biases_bounds_t &rhs) { + return sbp_msg_ssr_code_phase_biases_bounds_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_V4_SSR_MSG_SSR_CODE_PHASE_BIASES_BOUNDS_H */ diff --git a/c/include/libsbp/v4/ssr/MSG_SSR_GRIDDED_CORRECTION_BOUNDS.h b/c/include/libsbp/v4/ssr/MSG_SSR_GRIDDED_CORRECTION_BOUNDS.h new file mode 100644 index 0000000000..832f61a616 --- /dev/null +++ b/c/include/libsbp/v4/ssr/MSG_SSR_GRIDDED_CORRECTION_BOUNDS.h @@ -0,0 +1,194 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/ssr.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_V4_SSR_MSG_SSR_GRIDDED_CORRECTION_BOUNDS_H +#define LIBSBP_V4_SSR_MSG_SSR_GRIDDED_CORRECTION_BOUNDS_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_SSR_GRIDDED_CORRECTION_BOUNDS + * + *****************************************************************************/ +typedef struct { + u8 stub[SBP_MSG_SSR_GRIDDED_CORRECTION_BOUNDS_STUB_MAX]; + /** + * Number of elements in stub + * + * When sending a message fill in this field with the number elements set in + * stub before calling an appropriate libsbp send function + * + * When receiving a message query this field for the number of elements in + * stub. The value of any elements beyond the index specified in this field is + * undefined + */ + u8 n_stub; +} sbp_msg_ssr_gridded_correction_bounds_t; + +/** + * Get encoded size of an instance of sbp_msg_ssr_gridded_correction_bounds_t + * + * @param msg sbp_msg_ssr_gridded_correction_bounds_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_ssr_gridded_correction_bounds_encoded_len( + const sbp_msg_ssr_gridded_correction_bounds_t *msg) { + return SBP_MSG_SSR_GRIDDED_CORRECTION_BOUNDS_ENCODED_OVERHEAD + + (msg->n_stub * SBP_ENCODED_LEN_U8); +} + +/** + * Encode an instance of sbp_msg_ssr_gridded_correction_bounds_t to wire + * representation + * + * This function encodes the given instance in to the user provided buffer. The + * buffer provided to this function must be large enough to store the encoded + * message otherwise it will return SBP_ENCODE_ERROR without writing anything to + * the buffer. + * + * Specify the length of the destination buffer in the \p len parameter. If + * non-null the number of bytes written to the buffer will be returned in \p + * n_written. + * + * @param buf Destination buffer + * @param len Length of \p buf + * @param n_written If not null, on success will be set to the number of bytes + * written to \p buf + * @param msg Instance of sbp_msg_ssr_gridded_correction_bounds_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_gridded_correction_bounds_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_gridded_correction_bounds_t *msg); + +/** + * Decode an instance of sbp_msg_ssr_gridded_correction_bounds_t from wire + * representation + * + * This function decodes the wire representation of a + * sbp_msg_ssr_gridded_correction_bounds_t message to the given instance. The + * caller must specify the length of the buffer in the \p len parameter. If + * non-null the number of bytes read from the buffer will be returned in \p + * n_read. + * + * @param buf Wire representation of the sbp_msg_ssr_gridded_correction_bounds_t + * instance + * @param len Length of \p buf + * @param n_read If not null, on success will be set to the number of bytes read + * from \p buf + * @param msg Destination + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_gridded_correction_bounds_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_gridded_correction_bounds_t *msg); +/** + * Send an instance of sbp_msg_ssr_gridded_correction_bounds_t with the given + * write function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_ssr_gridded_correction_bounds_t + * + * The given message will be encoded to wire representation and passed in to the + * given write function callback. The write callback will be called several + * times for each invocation of this function. + * + * @param s SBP state + * @param sender_id SBP sender id + * @param msg Message to send + * @param write Write function + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_gridded_correction_bounds_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_gridded_correction_bounds_t *msg, sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_ssr_gridded_correction_bounds_t + * + * The two instances will be compared and a value returned consistent with the + * return codes of comparison functions from the C standard library + * + * 0 will be returned if \p a and \p b are considered equal + * A value less than 0 will be returned if \p a is considered to be less than \p + * b A value greater than 0 will be returned if \p b is considered to be greater + * than \p b + * + * @param a sbp_msg_ssr_gridded_correction_bounds_t instance + * @param b sbp_msg_ssr_gridded_correction_bounds_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_ssr_gridded_correction_bounds_cmp( + const sbp_msg_ssr_gridded_correction_bounds_t *a, + const sbp_msg_ssr_gridded_correction_bounds_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==( + const sbp_msg_ssr_gridded_correction_bounds_t &lhs, + const sbp_msg_ssr_gridded_correction_bounds_t &rhs) { + return sbp_msg_ssr_gridded_correction_bounds_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=( + const sbp_msg_ssr_gridded_correction_bounds_t &lhs, + const sbp_msg_ssr_gridded_correction_bounds_t &rhs) { + return sbp_msg_ssr_gridded_correction_bounds_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<( + const sbp_msg_ssr_gridded_correction_bounds_t &lhs, + const sbp_msg_ssr_gridded_correction_bounds_t &rhs) { + return sbp_msg_ssr_gridded_correction_bounds_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=( + const sbp_msg_ssr_gridded_correction_bounds_t &lhs, + const sbp_msg_ssr_gridded_correction_bounds_t &rhs) { + return sbp_msg_ssr_gridded_correction_bounds_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>( + const sbp_msg_ssr_gridded_correction_bounds_t &lhs, + const sbp_msg_ssr_gridded_correction_bounds_t &rhs) { + return sbp_msg_ssr_gridded_correction_bounds_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=( + const sbp_msg_ssr_gridded_correction_bounds_t &lhs, + const sbp_msg_ssr_gridded_correction_bounds_t &rhs) { + return sbp_msg_ssr_gridded_correction_bounds_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_V4_SSR_MSG_SSR_GRIDDED_CORRECTION_BOUNDS_H */ diff --git a/c/include/libsbp/v4/ssr/MSG_SSR_ORBIT_CLOCK_BOUNDS.h b/c/include/libsbp/v4/ssr/MSG_SSR_ORBIT_CLOCK_BOUNDS.h new file mode 100644 index 0000000000..e0a10f8321 --- /dev/null +++ b/c/include/libsbp/v4/ssr/MSG_SSR_ORBIT_CLOCK_BOUNDS.h @@ -0,0 +1,186 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/ssr.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_V4_SSR_MSG_SSR_ORBIT_CLOCK_BOUNDS_H +#define LIBSBP_V4_SSR_MSG_SSR_ORBIT_CLOCK_BOUNDS_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS + * + *****************************************************************************/ +typedef struct { + u8 stub[SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS_STUB_MAX]; + /** + * Number of elements in stub + * + * When sending a message fill in this field with the number elements set in + * stub before calling an appropriate libsbp send function + * + * When receiving a message query this field for the number of elements in + * stub. The value of any elements beyond the index specified in this field is + * undefined + */ + u8 n_stub; +} sbp_msg_ssr_orbit_clock_bounds_t; + +/** + * Get encoded size of an instance of sbp_msg_ssr_orbit_clock_bounds_t + * + * @param msg sbp_msg_ssr_orbit_clock_bounds_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_ssr_orbit_clock_bounds_encoded_len( + const sbp_msg_ssr_orbit_clock_bounds_t *msg) { + return SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS_ENCODED_OVERHEAD + + (msg->n_stub * SBP_ENCODED_LEN_U8); +} + +/** + * Encode an instance of sbp_msg_ssr_orbit_clock_bounds_t to wire representation + * + * This function encodes the given instance in to the user provided buffer. The + * buffer provided to this function must be large enough to store the encoded + * message otherwise it will return SBP_ENCODE_ERROR without writing anything to + * the buffer. + * + * Specify the length of the destination buffer in the \p len parameter. If + * non-null the number of bytes written to the buffer will be returned in \p + * n_written. + * + * @param buf Destination buffer + * @param len Length of \p buf + * @param n_written If not null, on success will be set to the number of bytes + * written to \p buf + * @param msg Instance of sbp_msg_ssr_orbit_clock_bounds_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_orbit_clock_bounds_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_orbit_clock_bounds_t *msg); + +/** + * Decode an instance of sbp_msg_ssr_orbit_clock_bounds_t from wire + * representation + * + * This function decodes the wire representation of a + * sbp_msg_ssr_orbit_clock_bounds_t message to the given instance. The caller + * must specify the length of the buffer in the \p len parameter. If non-null + * the number of bytes read from the buffer will be returned in \p n_read. + * + * @param buf Wire representation of the sbp_msg_ssr_orbit_clock_bounds_t + * instance + * @param len Length of \p buf + * @param n_read If not null, on success will be set to the number of bytes read + * from \p buf + * @param msg Destination + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_orbit_clock_bounds_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_orbit_clock_bounds_t *msg); +/** + * Send an instance of sbp_msg_ssr_orbit_clock_bounds_t with the given write + * function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_ssr_orbit_clock_bounds_t + * + * The given message will be encoded to wire representation and passed in to the + * given write function callback. The write callback will be called several + * times for each invocation of this function. + * + * @param s SBP state + * @param sender_id SBP sender id + * @param msg Message to send + * @param write Write function + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_orbit_clock_bounds_send( + sbp_state_t *s, u16 sender_id, const sbp_msg_ssr_orbit_clock_bounds_t *msg, + sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_ssr_orbit_clock_bounds_t + * + * The two instances will be compared and a value returned consistent with the + * return codes of comparison functions from the C standard library + * + * 0 will be returned if \p a and \p b are considered equal + * A value less than 0 will be returned if \p a is considered to be less than \p + * b A value greater than 0 will be returned if \p b is considered to be greater + * than \p b + * + * @param a sbp_msg_ssr_orbit_clock_bounds_t instance + * @param b sbp_msg_ssr_orbit_clock_bounds_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_ssr_orbit_clock_bounds_cmp( + const sbp_msg_ssr_orbit_clock_bounds_t *a, + const sbp_msg_ssr_orbit_clock_bounds_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==(const sbp_msg_ssr_orbit_clock_bounds_t &lhs, + const sbp_msg_ssr_orbit_clock_bounds_t &rhs) { + return sbp_msg_ssr_orbit_clock_bounds_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=(const sbp_msg_ssr_orbit_clock_bounds_t &lhs, + const sbp_msg_ssr_orbit_clock_bounds_t &rhs) { + return sbp_msg_ssr_orbit_clock_bounds_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<(const sbp_msg_ssr_orbit_clock_bounds_t &lhs, + const sbp_msg_ssr_orbit_clock_bounds_t &rhs) { + return sbp_msg_ssr_orbit_clock_bounds_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=(const sbp_msg_ssr_orbit_clock_bounds_t &lhs, + const sbp_msg_ssr_orbit_clock_bounds_t &rhs) { + return sbp_msg_ssr_orbit_clock_bounds_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>(const sbp_msg_ssr_orbit_clock_bounds_t &lhs, + const sbp_msg_ssr_orbit_clock_bounds_t &rhs) { + return sbp_msg_ssr_orbit_clock_bounds_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=(const sbp_msg_ssr_orbit_clock_bounds_t &lhs, + const sbp_msg_ssr_orbit_clock_bounds_t &rhs) { + return sbp_msg_ssr_orbit_clock_bounds_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_V4_SSR_MSG_SSR_ORBIT_CLOCK_BOUNDS_H */ diff --git a/c/include/libsbp/v4/ssr/MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION.h b/c/include/libsbp/v4/ssr/MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION.h new file mode 100644 index 0000000000..7c501100c4 --- /dev/null +++ b/c/include/libsbp/v4/ssr/MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION.h @@ -0,0 +1,196 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/ssr.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_V4_SSR_MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION_H +#define LIBSBP_V4_SSR_MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION + * + *****************************************************************************/ +typedef struct { + u8 stub[SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION_STUB_MAX]; + /** + * Number of elements in stub + * + * When sending a message fill in this field with the number elements set in + * stub before calling an appropriate libsbp send function + * + * When receiving a message query this field for the number of elements in + * stub. The value of any elements beyond the index specified in this field is + * undefined + */ + u8 n_stub; +} sbp_msg_ssr_orbit_clock_bounds_degradation_t; + +/** + * Get encoded size of an instance of + * sbp_msg_ssr_orbit_clock_bounds_degradation_t + * + * @param msg sbp_msg_ssr_orbit_clock_bounds_degradation_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_ssr_orbit_clock_bounds_degradation_encoded_len( + const sbp_msg_ssr_orbit_clock_bounds_degradation_t *msg) { + return SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION_ENCODED_OVERHEAD + + (msg->n_stub * SBP_ENCODED_LEN_U8); +} + +/** + * Encode an instance of sbp_msg_ssr_orbit_clock_bounds_degradation_t to wire + * representation + * + * This function encodes the given instance in to the user provided buffer. The + * buffer provided to this function must be large enough to store the encoded + * message otherwise it will return SBP_ENCODE_ERROR without writing anything to + * the buffer. + * + * Specify the length of the destination buffer in the \p len parameter. If + * non-null the number of bytes written to the buffer will be returned in \p + * n_written. + * + * @param buf Destination buffer + * @param len Length of \p buf + * @param n_written If not null, on success will be set to the number of bytes + * written to \p buf + * @param msg Instance of sbp_msg_ssr_orbit_clock_bounds_degradation_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_orbit_clock_bounds_degradation_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_orbit_clock_bounds_degradation_t *msg); + +/** + * Decode an instance of sbp_msg_ssr_orbit_clock_bounds_degradation_t from wire + * representation + * + * This function decodes the wire representation of a + * sbp_msg_ssr_orbit_clock_bounds_degradation_t message to the given instance. + * The caller must specify the length of the buffer in the \p len parameter. If + * non-null the number of bytes read from the buffer will be returned in \p + * n_read. + * + * @param buf Wire representation of the + * sbp_msg_ssr_orbit_clock_bounds_degradation_t instance + * @param len Length of \p buf + * @param n_read If not null, on success will be set to the number of bytes read + * from \p buf + * @param msg Destination + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_orbit_clock_bounds_degradation_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_orbit_clock_bounds_degradation_t *msg); +/** + * Send an instance of sbp_msg_ssr_orbit_clock_bounds_degradation_t with the + * given write function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_ssr_orbit_clock_bounds_degradation_t + * + * The given message will be encoded to wire representation and passed in to the + * given write function callback. The write callback will be called several + * times for each invocation of this function. + * + * @param s SBP state + * @param sender_id SBP sender id + * @param msg Message to send + * @param write Write function + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_orbit_clock_bounds_degradation_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_orbit_clock_bounds_degradation_t *msg, + sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_ssr_orbit_clock_bounds_degradation_t + * + * The two instances will be compared and a value returned consistent with the + * return codes of comparison functions from the C standard library + * + * 0 will be returned if \p a and \p b are considered equal + * A value less than 0 will be returned if \p a is considered to be less than \p + * b A value greater than 0 will be returned if \p b is considered to be greater + * than \p b + * + * @param a sbp_msg_ssr_orbit_clock_bounds_degradation_t instance + * @param b sbp_msg_ssr_orbit_clock_bounds_degradation_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_ssr_orbit_clock_bounds_degradation_cmp( + const sbp_msg_ssr_orbit_clock_bounds_degradation_t *a, + const sbp_msg_ssr_orbit_clock_bounds_degradation_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==( + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &lhs, + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &rhs) { + return sbp_msg_ssr_orbit_clock_bounds_degradation_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=( + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &lhs, + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &rhs) { + return sbp_msg_ssr_orbit_clock_bounds_degradation_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<( + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &lhs, + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &rhs) { + return sbp_msg_ssr_orbit_clock_bounds_degradation_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=( + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &lhs, + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &rhs) { + return sbp_msg_ssr_orbit_clock_bounds_degradation_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>( + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &lhs, + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &rhs) { + return sbp_msg_ssr_orbit_clock_bounds_degradation_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=( + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &lhs, + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &rhs) { + return sbp_msg_ssr_orbit_clock_bounds_degradation_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_V4_SSR_MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION_H */ diff --git a/c/include/libsbp/v4/ssr/MSG_SSR_STEC_CORRECTION.h b/c/include/libsbp/v4/ssr/MSG_SSR_STEC_CORRECTION.h index 3c884a91cd..aaa5e65704 100644 --- a/c/include/libsbp/v4/ssr/MSG_SSR_STEC_CORRECTION.h +++ b/c/include/libsbp/v4/ssr/MSG_SSR_STEC_CORRECTION.h @@ -27,8 +27,6 @@ #include #include -#include -#include #include #ifdef __cplusplus @@ -40,36 +38,19 @@ extern "C" { * SBP_MSG_SSR_STEC_CORRECTION * *****************************************************************************/ -/** STEC correction polynomial coefficients - * - * The Slant Total Electron Content per space vehicle, given as polynomial - * approximation for a given tile. This should be combined with the - * MSG_SSR_GRIDDED_CORRECTION message to get the state space representation of - * the atmospheric delay. - * - */ typedef struct { + u8 stub[SBP_MSG_SSR_STEC_CORRECTION_STUB_MAX]; /** - * Header of a STEC polynomial coefficient message. - */ - sbp_stec_header_t header; - - /** - * Array of STEC polynomial coefficients for each space vehicle. - */ - sbp_stec_sat_element_t - stec_sat_list[SBP_MSG_SSR_STEC_CORRECTION_STEC_SAT_LIST_MAX]; - /** - * Number of elements in stec_sat_list + * Number of elements in stub * * When sending a message fill in this field with the number elements set in - * stec_sat_list before calling an appropriate libsbp send function + * stub before calling an appropriate libsbp send function * * When receiving a message query this field for the number of elements in - * stec_sat_list. The value of any elements beyond the index specified in this - * field is undefined + * stub. The value of any elements beyond the index specified in this field is + * undefined */ - u8 n_stec_sat_list; + u8 n_stub; } sbp_msg_ssr_stec_correction_t; /** @@ -81,7 +62,7 @@ typedef struct { static inline size_t sbp_msg_ssr_stec_correction_encoded_len( const sbp_msg_ssr_stec_correction_t *msg) { return SBP_MSG_SSR_STEC_CORRECTION_ENCODED_OVERHEAD + - (msg->n_stec_sat_list * SBP_STEC_SAT_ELEMENT_ENCODED_LEN); + (msg->n_stub * SBP_ENCODED_LEN_U8); } /** diff --git a/c/include/libsbp/v4/ssr/MSG_SSR_STEC_CORRECTION_DEP.h b/c/include/libsbp/v4/ssr/MSG_SSR_STEC_CORRECTION_DEP.h new file mode 100644 index 0000000000..4d9a0af5b6 --- /dev/null +++ b/c/include/libsbp/v4/ssr/MSG_SSR_STEC_CORRECTION_DEP.h @@ -0,0 +1,206 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/ssr.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_V4_SSR_MSG_SSR_STEC_CORRECTION_DEP_H +#define LIBSBP_V4_SSR_MSG_SSR_STEC_CORRECTION_DEP_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_SSR_STEC_CORRECTION_DEP + * + *****************************************************************************/ +/** STEC correction polynomial coefficients + * + * The Slant Total Electron Content per space vehicle, given as polynomial + * approximation for a given tile. This should be combined with the + * MSG_SSR_GRIDDED_CORRECTION message to get the state space representation of + * the atmospheric delay. + * + */ +typedef struct { + /** + * Header of a STEC polynomial coefficient message. + */ + sbp_stec_header_t header; + + /** + * Array of STEC polynomial coefficients for each space vehicle. + */ + sbp_stec_sat_element_t + stec_sat_list[SBP_MSG_SSR_STEC_CORRECTION_DEP_STEC_SAT_LIST_MAX]; + /** + * Number of elements in stec_sat_list + * + * When sending a message fill in this field with the number elements set in + * stec_sat_list before calling an appropriate libsbp send function + * + * When receiving a message query this field for the number of elements in + * stec_sat_list. The value of any elements beyond the index specified in this + * field is undefined + */ + u8 n_stec_sat_list; +} sbp_msg_ssr_stec_correction_dep_t; + +/** + * Get encoded size of an instance of sbp_msg_ssr_stec_correction_dep_t + * + * @param msg sbp_msg_ssr_stec_correction_dep_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_ssr_stec_correction_dep_encoded_len( + const sbp_msg_ssr_stec_correction_dep_t *msg) { + return SBP_MSG_SSR_STEC_CORRECTION_DEP_ENCODED_OVERHEAD + + (msg->n_stec_sat_list * SBP_STEC_SAT_ELEMENT_ENCODED_LEN); +} + +/** + * Encode an instance of sbp_msg_ssr_stec_correction_dep_t to wire + * representation + * + * This function encodes the given instance in to the user provided buffer. The + * buffer provided to this function must be large enough to store the encoded + * message otherwise it will return SBP_ENCODE_ERROR without writing anything to + * the buffer. + * + * Specify the length of the destination buffer in the \p len parameter. If + * non-null the number of bytes written to the buffer will be returned in \p + * n_written. + * + * @param buf Destination buffer + * @param len Length of \p buf + * @param n_written If not null, on success will be set to the number of bytes + * written to \p buf + * @param msg Instance of sbp_msg_ssr_stec_correction_dep_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_stec_correction_dep_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_stec_correction_dep_t *msg); + +/** + * Decode an instance of sbp_msg_ssr_stec_correction_dep_t from wire + * representation + * + * This function decodes the wire representation of a + * sbp_msg_ssr_stec_correction_dep_t message to the given instance. The caller + * must specify the length of the buffer in the \p len parameter. If non-null + * the number of bytes read from the buffer will be returned in \p n_read. + * + * @param buf Wire representation of the sbp_msg_ssr_stec_correction_dep_t + * instance + * @param len Length of \p buf + * @param n_read If not null, on success will be set to the number of bytes read + * from \p buf + * @param msg Destination + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_stec_correction_dep_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_stec_correction_dep_t *msg); +/** + * Send an instance of sbp_msg_ssr_stec_correction_dep_t with the given write + * function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_ssr_stec_correction_dep_t + * + * The given message will be encoded to wire representation and passed in to the + * given write function callback. The write callback will be called several + * times for each invocation of this function. + * + * @param s SBP state + * @param sender_id SBP sender id + * @param msg Message to send + * @param write Write function + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_stec_correction_dep_send( + sbp_state_t *s, u16 sender_id, const sbp_msg_ssr_stec_correction_dep_t *msg, + sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_ssr_stec_correction_dep_t + * + * The two instances will be compared and a value returned consistent with the + * return codes of comparison functions from the C standard library + * + * 0 will be returned if \p a and \p b are considered equal + * A value less than 0 will be returned if \p a is considered to be less than \p + * b A value greater than 0 will be returned if \p b is considered to be greater + * than \p b + * + * @param a sbp_msg_ssr_stec_correction_dep_t instance + * @param b sbp_msg_ssr_stec_correction_dep_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_ssr_stec_correction_dep_cmp( + const sbp_msg_ssr_stec_correction_dep_t *a, + const sbp_msg_ssr_stec_correction_dep_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==(const sbp_msg_ssr_stec_correction_dep_t &lhs, + const sbp_msg_ssr_stec_correction_dep_t &rhs) { + return sbp_msg_ssr_stec_correction_dep_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=(const sbp_msg_ssr_stec_correction_dep_t &lhs, + const sbp_msg_ssr_stec_correction_dep_t &rhs) { + return sbp_msg_ssr_stec_correction_dep_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<(const sbp_msg_ssr_stec_correction_dep_t &lhs, + const sbp_msg_ssr_stec_correction_dep_t &rhs) { + return sbp_msg_ssr_stec_correction_dep_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=(const sbp_msg_ssr_stec_correction_dep_t &lhs, + const sbp_msg_ssr_stec_correction_dep_t &rhs) { + return sbp_msg_ssr_stec_correction_dep_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>(const sbp_msg_ssr_stec_correction_dep_t &lhs, + const sbp_msg_ssr_stec_correction_dep_t &rhs) { + return sbp_msg_ssr_stec_correction_dep_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=(const sbp_msg_ssr_stec_correction_dep_t &lhs, + const sbp_msg_ssr_stec_correction_dep_t &rhs) { + return sbp_msg_ssr_stec_correction_dep_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_V4_SSR_MSG_SSR_STEC_CORRECTION_DEP_H */ diff --git a/c/include/libsbp/v4/ssr/MSG_SSR_TILE_DEFINITION.h b/c/include/libsbp/v4/ssr/MSG_SSR_TILE_DEFINITION.h index d7d02b89d2..73c124b3d8 100644 --- a/c/include/libsbp/v4/ssr/MSG_SSR_TILE_DEFINITION.h +++ b/c/include/libsbp/v4/ssr/MSG_SSR_TILE_DEFINITION.h @@ -46,89 +46,18 @@ extern "C" { * */ typedef struct { + u8 stub[SBP_MSG_SSR_TILE_DEFINITION_STUB_MAX]; /** - * Unique identifier of the tile set this tile belongs to. - */ - u16 tile_set_id; - - /** - * Unique identifier of this tile in the tile set. - * See GNSS-SSR-ArrayOfCorrectionPoints field correctionPointSetID. - */ - u16 tile_id; - - /** - * North-West corner correction point latitude. - * - * The relation between the latitude X in the range [-90, 90] and the coded - * number N is: - * - * N = floor((X / 90) * 2^14) - * - * See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLatitude. [encoded - * degrees] - */ - s16 corner_nw_lat; - - /** - * North-West corner correction point longitude. - * - * The relation between the longitude X in the range [-180, 180] and the coded - * number N is: - * - * N = floor((X / 180) * 2^15) - * - * See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLongitude. - * [encoded degrees] - */ - s16 corner_nw_lon; - - /** - * Spacing of the correction points in the latitude direction. - * - * See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLatitude. [0.01 degrees] - */ - u16 spacing_lat; - - /** - * Spacing of the correction points in the longitude direction. - * - * See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLongitude. [0.01 degrees] - */ - u16 spacing_lon; - - /** - * Number of steps in the latitude direction. - * - * See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLatitude. - */ - u16 rows; - - /** - * Number of steps in the longitude direction. - * - * See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLongitude. - */ - u16 cols; - - /** - * Specifies the availability of correction data at the correction points in - * the array. - * - * If a specific bit is enabled (set to 1), the correction is not available. - * Only the first rows * cols bits are used, the remainder are set to 0. If - * there are more then 64 correction points the remaining corrections are - * always available. + * Number of elements in stub * - * Starting with the northwest corner of the array (top left on a north - * oriented map) the correction points are enumerated with row precedence - - * first row west to east, second row west to east, until last row west to - * east - ending with the southeast corner of the array. + * When sending a message fill in this field with the number elements set in + * stub before calling an appropriate libsbp send function * - * See GNSS-SSR-ArrayOfCorrectionPoints field bitmaskOfGrids but note the - * definition of the bits is inverted. + * When receiving a message query this field for the number of elements in + * stub. The value of any elements beyond the index specified in this field is + * undefined */ - u64 bitmask; + u8 n_stub; } sbp_msg_ssr_tile_definition_t; /** @@ -139,8 +68,8 @@ typedef struct { */ static inline size_t sbp_msg_ssr_tile_definition_encoded_len( const sbp_msg_ssr_tile_definition_t *msg) { - (void)msg; - return SBP_MSG_SSR_TILE_DEFINITION_ENCODED_LEN; + return SBP_MSG_SSR_TILE_DEFINITION_ENCODED_OVERHEAD + + (msg->n_stub * SBP_ENCODED_LEN_U8); } /** diff --git a/c/include/libsbp/v4/ssr/MSG_SSR_TILE_DEFINITION_DEP.h b/c/include/libsbp/v4/ssr/MSG_SSR_TILE_DEFINITION_DEP.h new file mode 100644 index 0000000000..e8eea9d93d --- /dev/null +++ b/c/include/libsbp/v4/ssr/MSG_SSR_TILE_DEFINITION_DEP.h @@ -0,0 +1,266 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/ssr.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_V4_SSR_MSG_SSR_TILE_DEFINITION_DEP_H +#define LIBSBP_V4_SSR_MSG_SSR_TILE_DEFINITION_DEP_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_SSR_TILE_DEFINITION_DEP + * + *****************************************************************************/ +/** Definition of a SSR atmospheric correction tile. + + * + * Provides the correction point coordinates for the atmospheric correction + values in the MSG_SSR_STEC_CORRECTION_DEP and MSG_SSR_GRIDDED_CORRECTION + messages. + * + */ +typedef struct { + /** + * Unique identifier of the tile set this tile belongs to. + */ + u16 tile_set_id; + + /** + * Unique identifier of this tile in the tile set. + * See GNSS-SSR-ArrayOfCorrectionPoints field correctionPointSetID. + */ + u16 tile_id; + + /** + * North-West corner correction point latitude. + * + * The relation between the latitude X in the range [-90, 90] and the coded + * number N is: + * + * N = floor((X / 90) * 2^14) + * + * See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLatitude. [encoded + * degrees] + */ + s16 corner_nw_lat; + + /** + * North-West corner correction point longitude. + * + * The relation between the longitude X in the range [-180, 180] and the coded + * number N is: + * + * N = floor((X / 180) * 2^15) + * + * See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLongitude. + * [encoded degrees] + */ + s16 corner_nw_lon; + + /** + * Spacing of the correction points in the latitude direction. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLatitude. [0.01 degrees] + */ + u16 spacing_lat; + + /** + * Spacing of the correction points in the longitude direction. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLongitude. [0.01 degrees] + */ + u16 spacing_lon; + + /** + * Number of steps in the latitude direction. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLatitude. + */ + u16 rows; + + /** + * Number of steps in the longitude direction. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLongitude. + */ + u16 cols; + + /** + * Specifies the availability of correction data at the correction points in + * the array. + * + * If a specific bit is enabled (set to 1), the correction is not available. + * Only the first rows * cols bits are used, the remainder are set to 0. If + * there are more then 64 correction points the remaining corrections are + * always available. + * + * Starting with the northwest corner of the array (top left on a north + * oriented map) the correction points are enumerated with row precedence - + * first row west to east, second row west to east, until last row west to + * east - ending with the southeast corner of the array. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field bitmaskOfGrids but note the + * definition of the bits is inverted. + */ + u64 bitmask; +} sbp_msg_ssr_tile_definition_dep_t; + +/** + * Get encoded size of an instance of sbp_msg_ssr_tile_definition_dep_t + * + * @param msg sbp_msg_ssr_tile_definition_dep_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_ssr_tile_definition_dep_encoded_len( + const sbp_msg_ssr_tile_definition_dep_t *msg) { + (void)msg; + return SBP_MSG_SSR_TILE_DEFINITION_DEP_ENCODED_LEN; +} + +/** + * Encode an instance of sbp_msg_ssr_tile_definition_dep_t to wire + * representation + * + * This function encodes the given instance in to the user provided buffer. The + * buffer provided to this function must be large enough to store the encoded + * message otherwise it will return SBP_ENCODE_ERROR without writing anything to + * the buffer. + * + * Specify the length of the destination buffer in the \p len parameter. If + * non-null the number of bytes written to the buffer will be returned in \p + * n_written. + * + * @param buf Destination buffer + * @param len Length of \p buf + * @param n_written If not null, on success will be set to the number of bytes + * written to \p buf + * @param msg Instance of sbp_msg_ssr_tile_definition_dep_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_tile_definition_dep_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_tile_definition_dep_t *msg); + +/** + * Decode an instance of sbp_msg_ssr_tile_definition_dep_t from wire + * representation + * + * This function decodes the wire representation of a + * sbp_msg_ssr_tile_definition_dep_t message to the given instance. The caller + * must specify the length of the buffer in the \p len parameter. If non-null + * the number of bytes read from the buffer will be returned in \p n_read. + * + * @param buf Wire representation of the sbp_msg_ssr_tile_definition_dep_t + * instance + * @param len Length of \p buf + * @param n_read If not null, on success will be set to the number of bytes read + * from \p buf + * @param msg Destination + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_tile_definition_dep_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_tile_definition_dep_t *msg); +/** + * Send an instance of sbp_msg_ssr_tile_definition_dep_t with the given write + * function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_ssr_tile_definition_dep_t + * + * The given message will be encoded to wire representation and passed in to the + * given write function callback. The write callback will be called several + * times for each invocation of this function. + * + * @param s SBP state + * @param sender_id SBP sender id + * @param msg Message to send + * @param write Write function + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_tile_definition_dep_send( + sbp_state_t *s, u16 sender_id, const sbp_msg_ssr_tile_definition_dep_t *msg, + sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_ssr_tile_definition_dep_t + * + * The two instances will be compared and a value returned consistent with the + * return codes of comparison functions from the C standard library + * + * 0 will be returned if \p a and \p b are considered equal + * A value less than 0 will be returned if \p a is considered to be less than \p + * b A value greater than 0 will be returned if \p b is considered to be greater + * than \p b + * + * @param a sbp_msg_ssr_tile_definition_dep_t instance + * @param b sbp_msg_ssr_tile_definition_dep_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_ssr_tile_definition_dep_cmp( + const sbp_msg_ssr_tile_definition_dep_t *a, + const sbp_msg_ssr_tile_definition_dep_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==(const sbp_msg_ssr_tile_definition_dep_t &lhs, + const sbp_msg_ssr_tile_definition_dep_t &rhs) { + return sbp_msg_ssr_tile_definition_dep_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=(const sbp_msg_ssr_tile_definition_dep_t &lhs, + const sbp_msg_ssr_tile_definition_dep_t &rhs) { + return sbp_msg_ssr_tile_definition_dep_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<(const sbp_msg_ssr_tile_definition_dep_t &lhs, + const sbp_msg_ssr_tile_definition_dep_t &rhs) { + return sbp_msg_ssr_tile_definition_dep_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=(const sbp_msg_ssr_tile_definition_dep_t &lhs, + const sbp_msg_ssr_tile_definition_dep_t &rhs) { + return sbp_msg_ssr_tile_definition_dep_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>(const sbp_msg_ssr_tile_definition_dep_t &lhs, + const sbp_msg_ssr_tile_definition_dep_t &rhs) { + return sbp_msg_ssr_tile_definition_dep_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=(const sbp_msg_ssr_tile_definition_dep_t &lhs, + const sbp_msg_ssr_tile_definition_dep_t &rhs) { + return sbp_msg_ssr_tile_definition_dep_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_V4_SSR_MSG_SSR_TILE_DEFINITION_DEP_H */ diff --git a/c/include/libsbp/version.h b/c/include/libsbp/version.h index da7bdbad94..c5a0b71dee 100644 --- a/c/include/libsbp/version.h +++ b/c/include/libsbp/version.h @@ -30,6 +30,9 @@ /** Full SBP version string. */ #define SBP_VERSION "4.2.1-alpha" +/** Is this a staging branch? */ +#define SBP_STAGING 0 + /** \} */ #endif /* LIBSBP_VERSION_H */ \ No newline at end of file diff --git a/c/src/include/libsbp/internal/v4/integrity.h b/c/src/include/libsbp/internal/v4/integrity.h new file mode 100644 index 0000000000..e61261b598 --- /dev/null +++ b/c/src/include/libsbp/internal/v4/integrity.h @@ -0,0 +1,156 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/integrity.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_INTERNAL_V4_INTEGRITY_H +#define LIBSBP_INTERNAL_V4_INTEGRITY_H + +#include + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Internal function to encode an SBP type to a buffer + * + * @param ctx Encode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_flag_high_level_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_flag_high_level_t *msg); + +/** + * Internal function to decode an SBP type from a buffer + * + * @param ctx Decode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_flag_high_level_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_flag_high_level_t *msg); + +/** + * Internal function to encode an SBP type to a buffer + * + * @param ctx Encode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_flag_satellites_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_flag_satellites_t *msg); + +/** + * Internal function to decode an SBP type from a buffer + * + * @param ctx Decode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_flag_satellites_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_flag_satellites_t *msg); + +/** + * Internal function to encode an SBP type to a buffer + * + * @param ctx Encode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_flag_tropo_grid_points_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_flag_tropo_grid_points_t *msg); + +/** + * Internal function to decode an SBP type from a buffer + * + * @param ctx Decode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_flag_tropo_grid_points_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_flag_tropo_grid_points_t *msg); + +/** + * Internal function to encode an SBP type to a buffer + * + * @param ctx Encode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_flag_iono_grid_points_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_flag_iono_grid_points_t *msg); + +/** + * Internal function to decode an SBP type from a buffer + * + * @param ctx Decode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_flag_iono_grid_points_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_flag_iono_grid_points_t *msg); + +/** + * Internal function to encode an SBP type to a buffer + * + * @param ctx Encode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_flag_iono_tile_sat_los_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_flag_iono_tile_sat_los_t *msg); + +/** + * Internal function to decode an SBP type from a buffer + * + * @param ctx Decode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_flag_iono_tile_sat_los_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_flag_iono_tile_sat_los_t *msg); + +/** + * Internal function to encode an SBP type to a buffer + * + * @param ctx Encode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_flag_iono_grid_point_sat_los_encode_internal( + sbp_encode_ctx_t *ctx, + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t *msg); + +/** + * Internal function to decode an SBP type from a buffer + * + * @param ctx Decode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_flag_iono_grid_point_sat_los_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_flag_iono_grid_point_sat_los_t *msg); + +#ifdef __cplusplus +} +#endif + +#endif /* LIBSBP_INTERNAL_V4_INTEGRITY_H */ diff --git a/c/src/include/libsbp/internal/v4/navigation.h b/c/src/include/libsbp/internal/v4/navigation.h index df635d37c8..213d878b87 100644 --- a/c/src/include/libsbp/internal/v4/navigation.h +++ b/c/src/include/libsbp/internal/v4/navigation.h @@ -806,6 +806,45 @@ bool sbp_msg_protection_level_encode_internal( bool sbp_msg_protection_level_decode_internal(sbp_decode_ctx_t *ctx, sbp_msg_protection_level_t *msg); +/** + * Internal function to encode an SBP type to a buffer + * + * @param ctx Encode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_gps_leap_second_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_gps_leap_second_t *msg); + +/** + * Internal function to decode an SBP type from a buffer + * + * @param ctx Decode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_gps_leap_second_decode_internal(sbp_decode_ctx_t *ctx, + sbp_msg_gps_leap_second_t *msg); + +/** + * Internal function to encode an SBP type to a buffer + * + * @param ctx Encode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_itrf_encode_internal(sbp_encode_ctx_t *ctx, + const sbp_msg_itrf_t *msg); + +/** + * Internal function to decode an SBP type from a buffer + * + * @param ctx Decode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_itrf_decode_internal(sbp_decode_ctx_t *ctx, sbp_msg_itrf_t *msg); + #ifdef __cplusplus } #endif diff --git a/c/src/include/libsbp/internal/v4/ssr.h b/c/src/include/libsbp/internal/v4/ssr.h index 8585b83ac4..03715a82f1 100644 --- a/c/src/include/libsbp/internal/v4/ssr.h +++ b/c/src/include/libsbp/internal/v4/ssr.h @@ -269,6 +269,26 @@ bool sbp_msg_ssr_phase_biases_encode_internal( bool sbp_msg_ssr_phase_biases_decode_internal(sbp_decode_ctx_t *ctx, sbp_msg_ssr_phase_biases_t *msg); +/** + * Internal function to encode an SBP type to a buffer + * + * @param ctx Encode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_stec_correction_dep_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_stec_correction_dep_t *msg); + +/** + * Internal function to decode an SBP type from a buffer + * + * @param ctx Decode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_stec_correction_dep_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_stec_correction_dep_t *msg); + /** * Internal function to encode an SBP type to a buffer * @@ -309,6 +329,46 @@ bool sbp_msg_ssr_gridded_correction_encode_internal( bool sbp_msg_ssr_gridded_correction_decode_internal( sbp_decode_ctx_t *ctx, sbp_msg_ssr_gridded_correction_t *msg); +/** + * Internal function to encode an SBP type to a buffer + * + * @param ctx Encode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_gridded_correction_bounds_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_gridded_correction_bounds_t *msg); + +/** + * Internal function to decode an SBP type from a buffer + * + * @param ctx Decode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_gridded_correction_bounds_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_gridded_correction_bounds_t *msg); + +/** + * Internal function to encode an SBP type to a buffer + * + * @param ctx Encode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_tile_definition_dep_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_tile_definition_dep_t *msg); + +/** + * Internal function to decode an SBP type from a buffer + * + * @param ctx Decode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_tile_definition_dep_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_tile_definition_dep_t *msg); + /** * Internal function to encode an SBP type to a buffer * @@ -530,6 +590,67 @@ bool sbp_msg_ssr_grid_definition_dep_a_encode_internal( bool sbp_msg_ssr_grid_definition_dep_a_decode_internal( sbp_decode_ctx_t *ctx, sbp_msg_ssr_grid_definition_dep_a_t *msg); +/** + * Internal function to encode an SBP type to a buffer + * + * @param ctx Encode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_orbit_clock_bounds_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_orbit_clock_bounds_t *msg); + +/** + * Internal function to decode an SBP type from a buffer + * + * @param ctx Decode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_orbit_clock_bounds_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_orbit_clock_bounds_t *msg); + +/** + * Internal function to encode an SBP type to a buffer + * + * @param ctx Encode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_code_phase_biases_bounds_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_code_phase_biases_bounds_t *msg); + +/** + * Internal function to decode an SBP type from a buffer + * + * @param ctx Decode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_code_phase_biases_bounds_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_code_phase_biases_bounds_t *msg); + +/** + * Internal function to encode an SBP type to a buffer + * + * @param ctx Encode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_orbit_clock_bounds_degradation_encode_internal( + sbp_encode_ctx_t *ctx, + const sbp_msg_ssr_orbit_clock_bounds_degradation_t *msg); + +/** + * Internal function to decode an SBP type from a buffer + * + * @param ctx Decode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_orbit_clock_bounds_degradation_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_orbit_clock_bounds_degradation_t *msg); + #ifdef __cplusplus } #endif diff --git a/c/src/v4/integrity.c b/c/src/v4/integrity.c new file mode 100644 index 0000000000..1fd87c172d --- /dev/null +++ b/c/src/v4/integrity.c @@ -0,0 +1,509 @@ +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/integrity.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +bool sbp_msg_ssr_flag_high_level_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_flag_high_level_t *msg) { + for (size_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_encode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_flag_high_level_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_high_level_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_flag_high_level_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_ssr_flag_high_level_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_flag_high_level_t *msg) { + msg->n_stub = (uint8_t)((ctx->buf_len - ctx->offset) / SBP_ENCODED_LEN_U8); + for (uint8_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_decode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_flag_high_level_decode(const uint8_t *buf, uint8_t len, + uint8_t *n_read, + sbp_msg_ssr_flag_high_level_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_flag_high_level_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_ssr_flag_high_level_send(sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_flag_high_level_t *msg, + sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = sbp_msg_ssr_flag_high_level_encode(payload, sizeof(payload), + &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_payload_send(s, SBP_MSG_SSR_FLAG_HIGH_LEVEL, sender_id, + payload_len, payload, write); +} + +int sbp_msg_ssr_flag_high_level_cmp(const sbp_msg_ssr_flag_high_level_t *a, + const sbp_msg_ssr_flag_high_level_t *b) { + int ret = 0; + + ret = sbp_u8_cmp(&a->n_stub, &b->n_stub); + for (uint8_t i = 0; ret == 0 && i < a->n_stub; i++) { + ret = sbp_u8_cmp(&a->stub[i], &b->stub[i]); + } + if (ret != 0) { + return ret; + } + return ret; +} + +bool sbp_msg_ssr_flag_satellites_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_flag_satellites_t *msg) { + for (size_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_encode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_flag_satellites_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_satellites_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_flag_satellites_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_ssr_flag_satellites_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_flag_satellites_t *msg) { + msg->n_stub = (uint8_t)((ctx->buf_len - ctx->offset) / SBP_ENCODED_LEN_U8); + for (uint8_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_decode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_flag_satellites_decode(const uint8_t *buf, uint8_t len, + uint8_t *n_read, + sbp_msg_ssr_flag_satellites_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_flag_satellites_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_ssr_flag_satellites_send(sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_flag_satellites_t *msg, + sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = sbp_msg_ssr_flag_satellites_encode(payload, sizeof(payload), + &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_payload_send(s, SBP_MSG_SSR_FLAG_SATELLITES, sender_id, + payload_len, payload, write); +} + +int sbp_msg_ssr_flag_satellites_cmp(const sbp_msg_ssr_flag_satellites_t *a, + const sbp_msg_ssr_flag_satellites_t *b) { + int ret = 0; + + ret = sbp_u8_cmp(&a->n_stub, &b->n_stub); + for (uint8_t i = 0; ret == 0 && i < a->n_stub; i++) { + ret = sbp_u8_cmp(&a->stub[i], &b->stub[i]); + } + if (ret != 0) { + return ret; + } + return ret; +} + +bool sbp_msg_ssr_flag_tropo_grid_points_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_flag_tropo_grid_points_t *msg) { + for (size_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_encode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_flag_tropo_grid_points_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_tropo_grid_points_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_flag_tropo_grid_points_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_ssr_flag_tropo_grid_points_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_flag_tropo_grid_points_t *msg) { + msg->n_stub = (uint8_t)((ctx->buf_len - ctx->offset) / SBP_ENCODED_LEN_U8); + for (uint8_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_decode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_flag_tropo_grid_points_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_tropo_grid_points_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_flag_tropo_grid_points_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_ssr_flag_tropo_grid_points_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_flag_tropo_grid_points_t *msg, sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = sbp_msg_ssr_flag_tropo_grid_points_encode(payload, sizeof(payload), + &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_payload_send(s, SBP_MSG_SSR_FLAG_TROPO_GRID_POINTS, sender_id, + payload_len, payload, write); +} + +int sbp_msg_ssr_flag_tropo_grid_points_cmp( + const sbp_msg_ssr_flag_tropo_grid_points_t *a, + const sbp_msg_ssr_flag_tropo_grid_points_t *b) { + int ret = 0; + + ret = sbp_u8_cmp(&a->n_stub, &b->n_stub); + for (uint8_t i = 0; ret == 0 && i < a->n_stub; i++) { + ret = sbp_u8_cmp(&a->stub[i], &b->stub[i]); + } + if (ret != 0) { + return ret; + } + return ret; +} + +bool sbp_msg_ssr_flag_iono_grid_points_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_flag_iono_grid_points_t *msg) { + for (size_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_encode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_flag_iono_grid_points_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_iono_grid_points_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_flag_iono_grid_points_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_ssr_flag_iono_grid_points_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_flag_iono_grid_points_t *msg) { + msg->n_stub = (uint8_t)((ctx->buf_len - ctx->offset) / SBP_ENCODED_LEN_U8); + for (uint8_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_decode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_flag_iono_grid_points_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_iono_grid_points_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_flag_iono_grid_points_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_ssr_flag_iono_grid_points_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_flag_iono_grid_points_t *msg, sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = sbp_msg_ssr_flag_iono_grid_points_encode(payload, sizeof(payload), + &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_payload_send(s, SBP_MSG_SSR_FLAG_IONO_GRID_POINTS, sender_id, + payload_len, payload, write); +} + +int sbp_msg_ssr_flag_iono_grid_points_cmp( + const sbp_msg_ssr_flag_iono_grid_points_t *a, + const sbp_msg_ssr_flag_iono_grid_points_t *b) { + int ret = 0; + + ret = sbp_u8_cmp(&a->n_stub, &b->n_stub); + for (uint8_t i = 0; ret == 0 && i < a->n_stub; i++) { + ret = sbp_u8_cmp(&a->stub[i], &b->stub[i]); + } + if (ret != 0) { + return ret; + } + return ret; +} + +bool sbp_msg_ssr_flag_iono_tile_sat_los_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_flag_iono_tile_sat_los_t *msg) { + for (size_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_encode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_flag_iono_tile_sat_los_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_iono_tile_sat_los_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_flag_iono_tile_sat_los_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_ssr_flag_iono_tile_sat_los_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_flag_iono_tile_sat_los_t *msg) { + msg->n_stub = (uint8_t)((ctx->buf_len - ctx->offset) / SBP_ENCODED_LEN_U8); + for (uint8_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_decode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_flag_iono_tile_sat_los_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_iono_tile_sat_los_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_flag_iono_tile_sat_los_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_ssr_flag_iono_tile_sat_los_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_flag_iono_tile_sat_los_t *msg, sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = sbp_msg_ssr_flag_iono_tile_sat_los_encode(payload, sizeof(payload), + &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_payload_send(s, SBP_MSG_SSR_FLAG_IONO_TILE_SAT_LOS, sender_id, + payload_len, payload, write); +} + +int sbp_msg_ssr_flag_iono_tile_sat_los_cmp( + const sbp_msg_ssr_flag_iono_tile_sat_los_t *a, + const sbp_msg_ssr_flag_iono_tile_sat_los_t *b) { + int ret = 0; + + ret = sbp_u8_cmp(&a->n_stub, &b->n_stub); + for (uint8_t i = 0; ret == 0 && i < a->n_stub; i++) { + ret = sbp_u8_cmp(&a->stub[i], &b->stub[i]); + } + if (ret != 0) { + return ret; + } + return ret; +} + +bool sbp_msg_ssr_flag_iono_grid_point_sat_los_encode_internal( + sbp_encode_ctx_t *ctx, + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t *msg) { + for (size_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_encode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_flag_iono_grid_point_sat_los_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_flag_iono_grid_point_sat_los_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_ssr_flag_iono_grid_point_sat_los_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_flag_iono_grid_point_sat_los_t *msg) { + msg->n_stub = (uint8_t)((ctx->buf_len - ctx->offset) / SBP_ENCODED_LEN_U8); + for (uint8_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_decode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_flag_iono_grid_point_sat_los_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_iono_grid_point_sat_los_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_flag_iono_grid_point_sat_los_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_ssr_flag_iono_grid_point_sat_los_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t *msg, + sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = sbp_msg_ssr_flag_iono_grid_point_sat_los_encode( + payload, sizeof(payload), &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_payload_send(s, SBP_MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS, + sender_id, payload_len, payload, write); +} + +int sbp_msg_ssr_flag_iono_grid_point_sat_los_cmp( + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t *a, + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t *b) { + int ret = 0; + + ret = sbp_u8_cmp(&a->n_stub, &b->n_stub); + for (uint8_t i = 0; ret == 0 && i < a->n_stub; i++) { + ret = sbp_u8_cmp(&a->stub[i], &b->stub[i]); + } + if (ret != 0) { + return ret; + } + return ret; +} diff --git a/c/src/v4/navigation.c b/c/src/v4/navigation.c index fbf90beca2..d191f65d4b 100644 --- a/c/src/v4/navigation.c +++ b/c/src/v4/navigation.c @@ -5971,3 +5971,158 @@ int sbp_msg_protection_level_cmp(const sbp_msg_protection_level_t *a, } return ret; } + +bool sbp_msg_gps_leap_second_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_gps_leap_second_t *msg) { + for (size_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_encode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_gps_leap_second_encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_gps_leap_second_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_gps_leap_second_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_gps_leap_second_decode_internal(sbp_decode_ctx_t *ctx, + sbp_msg_gps_leap_second_t *msg) { + msg->n_stub = (uint8_t)((ctx->buf_len - ctx->offset) / SBP_ENCODED_LEN_U8); + for (uint8_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_decode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_gps_leap_second_decode(const uint8_t *buf, uint8_t len, + uint8_t *n_read, + sbp_msg_gps_leap_second_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_gps_leap_second_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_gps_leap_second_send(sbp_state_t *s, u16 sender_id, + const sbp_msg_gps_leap_second_t *msg, + sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = sbp_msg_gps_leap_second_encode(payload, sizeof(payload), + &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_payload_send(s, SBP_MSG_GPS_LEAP_SECOND, sender_id, payload_len, + payload, write); +} + +int sbp_msg_gps_leap_second_cmp(const sbp_msg_gps_leap_second_t *a, + const sbp_msg_gps_leap_second_t *b) { + int ret = 0; + + ret = sbp_u8_cmp(&a->n_stub, &b->n_stub); + for (uint8_t i = 0; ret == 0 && i < a->n_stub; i++) { + ret = sbp_u8_cmp(&a->stub[i], &b->stub[i]); + } + if (ret != 0) { + return ret; + } + return ret; +} + +bool sbp_msg_itrf_encode_internal(sbp_encode_ctx_t *ctx, + const sbp_msg_itrf_t *msg) { + for (size_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_encode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_itrf_encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_itrf_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_itrf_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_itrf_decode_internal(sbp_decode_ctx_t *ctx, sbp_msg_itrf_t *msg) { + msg->n_stub = (uint8_t)((ctx->buf_len - ctx->offset) / SBP_ENCODED_LEN_U8); + for (uint8_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_decode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_itrf_decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_itrf_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_itrf_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_itrf_send(sbp_state_t *s, u16 sender_id, const sbp_msg_itrf_t *msg, + sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = sbp_msg_itrf_encode(payload, sizeof(payload), &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_payload_send(s, SBP_MSG_ITRF, sender_id, payload_len, payload, + write); +} + +int sbp_msg_itrf_cmp(const sbp_msg_itrf_t *a, const sbp_msg_itrf_t *b) { + int ret = 0; + + ret = sbp_u8_cmp(&a->n_stub, &b->n_stub); + for (uint8_t i = 0; ret == 0 && i < a->n_stub; i++) { + ret = sbp_u8_cmp(&a->stub[i], &b->stub[i]); + } + if (ret != 0) { + return ret; + } + return ret; +} diff --git a/c/src/v4/ssr.c b/c/src/v4/ssr.c index e881d8b600..389665af84 100644 --- a/c/src/v4/ssr.c +++ b/c/src/v4/ssr.c @@ -1348,8 +1348,8 @@ int sbp_msg_ssr_phase_biases_cmp(const sbp_msg_ssr_phase_biases_t *a, return ret; } -bool sbp_msg_ssr_stec_correction_encode_internal( - sbp_encode_ctx_t *ctx, const sbp_msg_ssr_stec_correction_t *msg) { +bool sbp_msg_ssr_stec_correction_dep_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_stec_correction_dep_t *msg) { if (!sbp_stec_header_encode_internal(ctx, &msg->header)) { return false; } @@ -1361,14 +1361,14 @@ bool sbp_msg_ssr_stec_correction_encode_internal( return true; } -s8 sbp_msg_ssr_stec_correction_encode( +s8 sbp_msg_ssr_stec_correction_dep_encode( uint8_t *buf, uint8_t len, uint8_t *n_written, - const sbp_msg_ssr_stec_correction_t *msg) { + const sbp_msg_ssr_stec_correction_dep_t *msg) { sbp_encode_ctx_t ctx; ctx.buf = buf; ctx.buf_len = len; ctx.offset = 0; - if (!sbp_msg_ssr_stec_correction_encode_internal(&ctx, msg)) { + if (!sbp_msg_ssr_stec_correction_dep_encode_internal(&ctx, msg)) { return SBP_ENCODE_ERROR; } if (n_written != NULL) { @@ -1377,8 +1377,8 @@ s8 sbp_msg_ssr_stec_correction_encode( return SBP_OK; } -bool sbp_msg_ssr_stec_correction_decode_internal( - sbp_decode_ctx_t *ctx, sbp_msg_ssr_stec_correction_t *msg) { +bool sbp_msg_ssr_stec_correction_dep_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_stec_correction_dep_t *msg) { if (!sbp_stec_header_decode_internal(ctx, &msg->header)) { return false; } @@ -1392,6 +1392,93 @@ bool sbp_msg_ssr_stec_correction_decode_internal( return true; } +s8 sbp_msg_ssr_stec_correction_dep_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_stec_correction_dep_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_stec_correction_dep_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_ssr_stec_correction_dep_send( + sbp_state_t *s, u16 sender_id, const sbp_msg_ssr_stec_correction_dep_t *msg, + sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = sbp_msg_ssr_stec_correction_dep_encode(payload, sizeof(payload), + &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_payload_send(s, SBP_MSG_SSR_STEC_CORRECTION_DEP, sender_id, + payload_len, payload, write); +} + +int sbp_msg_ssr_stec_correction_dep_cmp( + const sbp_msg_ssr_stec_correction_dep_t *a, + const sbp_msg_ssr_stec_correction_dep_t *b) { + int ret = 0; + + ret = sbp_stec_header_cmp(&a->header, &b->header); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->n_stec_sat_list, &b->n_stec_sat_list); + for (uint8_t i = 0; ret == 0 && i < a->n_stec_sat_list; i++) { + ret = sbp_stec_sat_element_cmp(&a->stec_sat_list[i], &b->stec_sat_list[i]); + } + if (ret != 0) { + return ret; + } + return ret; +} + +bool sbp_msg_ssr_stec_correction_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_stec_correction_t *msg) { + for (size_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_encode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_stec_correction_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_stec_correction_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_stec_correction_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_ssr_stec_correction_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_stec_correction_t *msg) { + msg->n_stub = (uint8_t)((ctx->buf_len - ctx->offset) / SBP_ENCODED_LEN_U8); + for (uint8_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_decode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + s8 sbp_msg_ssr_stec_correction_decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, sbp_msg_ssr_stec_correction_t *msg) { @@ -1426,14 +1513,9 @@ int sbp_msg_ssr_stec_correction_cmp(const sbp_msg_ssr_stec_correction_t *a, const sbp_msg_ssr_stec_correction_t *b) { int ret = 0; - ret = sbp_stec_header_cmp(&a->header, &b->header); - if (ret != 0) { - return ret; - } - - ret = sbp_u8_cmp(&a->n_stec_sat_list, &b->n_stec_sat_list); - for (uint8_t i = 0; ret == 0 && i < a->n_stec_sat_list; i++) { - ret = sbp_stec_sat_element_cmp(&a->stec_sat_list[i], &b->stec_sat_list[i]); + ret = sbp_u8_cmp(&a->n_stub, &b->n_stub); + for (uint8_t i = 0; ret == 0 && i < a->n_stub; i++) { + ret = sbp_u8_cmp(&a->stub[i], &b->stub[i]); } if (ret != 0) { return ret; @@ -1560,8 +1642,90 @@ int sbp_msg_ssr_gridded_correction_cmp( return ret; } -bool sbp_msg_ssr_tile_definition_encode_internal( - sbp_encode_ctx_t *ctx, const sbp_msg_ssr_tile_definition_t *msg) { +bool sbp_msg_ssr_gridded_correction_bounds_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_gridded_correction_bounds_t *msg) { + for (size_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_encode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_gridded_correction_bounds_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_gridded_correction_bounds_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_gridded_correction_bounds_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_ssr_gridded_correction_bounds_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_gridded_correction_bounds_t *msg) { + msg->n_stub = (uint8_t)((ctx->buf_len - ctx->offset) / SBP_ENCODED_LEN_U8); + for (uint8_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_decode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_gridded_correction_bounds_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_gridded_correction_bounds_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_gridded_correction_bounds_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_ssr_gridded_correction_bounds_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_gridded_correction_bounds_t *msg, sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = sbp_msg_ssr_gridded_correction_bounds_encode( + payload, sizeof(payload), &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_payload_send(s, SBP_MSG_SSR_GRIDDED_CORRECTION_BOUNDS, sender_id, + payload_len, payload, write); +} + +int sbp_msg_ssr_gridded_correction_bounds_cmp( + const sbp_msg_ssr_gridded_correction_bounds_t *a, + const sbp_msg_ssr_gridded_correction_bounds_t *b) { + int ret = 0; + + ret = sbp_u8_cmp(&a->n_stub, &b->n_stub); + for (uint8_t i = 0; ret == 0 && i < a->n_stub; i++) { + ret = sbp_u8_cmp(&a->stub[i], &b->stub[i]); + } + if (ret != 0) { + return ret; + } + return ret; +} + +bool sbp_msg_ssr_tile_definition_dep_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_tile_definition_dep_t *msg) { if (!sbp_u16_encode(ctx, &msg->tile_set_id)) { return false; } @@ -1592,14 +1756,14 @@ bool sbp_msg_ssr_tile_definition_encode_internal( return true; } -s8 sbp_msg_ssr_tile_definition_encode( +s8 sbp_msg_ssr_tile_definition_dep_encode( uint8_t *buf, uint8_t len, uint8_t *n_written, - const sbp_msg_ssr_tile_definition_t *msg) { + const sbp_msg_ssr_tile_definition_dep_t *msg) { sbp_encode_ctx_t ctx; ctx.buf = buf; ctx.buf_len = len; ctx.offset = 0; - if (!sbp_msg_ssr_tile_definition_encode_internal(&ctx, msg)) { + if (!sbp_msg_ssr_tile_definition_dep_encode_internal(&ctx, msg)) { return SBP_ENCODE_ERROR; } if (n_written != NULL) { @@ -1608,8 +1772,8 @@ s8 sbp_msg_ssr_tile_definition_encode( return SBP_OK; } -bool sbp_msg_ssr_tile_definition_decode_internal( - sbp_decode_ctx_t *ctx, sbp_msg_ssr_tile_definition_t *msg) { +bool sbp_msg_ssr_tile_definition_dep_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_tile_definition_dep_t *msg) { if (!sbp_u16_decode(ctx, &msg->tile_set_id)) { return false; } @@ -1640,14 +1804,14 @@ bool sbp_msg_ssr_tile_definition_decode_internal( return true; } -s8 sbp_msg_ssr_tile_definition_decode(const uint8_t *buf, uint8_t len, - uint8_t *n_read, - sbp_msg_ssr_tile_definition_t *msg) { +s8 sbp_msg_ssr_tile_definition_dep_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_tile_definition_dep_t *msg) { sbp_decode_ctx_t ctx; ctx.buf = buf; ctx.buf_len = len; ctx.offset = 0; - if (!sbp_msg_ssr_tile_definition_decode_internal(&ctx, msg)) { + if (!sbp_msg_ssr_tile_definition_dep_decode_internal(&ctx, msg)) { return SBP_DECODE_ERROR; } if (n_read != NULL) { @@ -1656,22 +1820,23 @@ s8 sbp_msg_ssr_tile_definition_decode(const uint8_t *buf, uint8_t len, return SBP_OK; } -s8 sbp_msg_ssr_tile_definition_send(sbp_state_t *s, u16 sender_id, - const sbp_msg_ssr_tile_definition_t *msg, - sbp_write_fn_t write) { +s8 sbp_msg_ssr_tile_definition_dep_send( + sbp_state_t *s, u16 sender_id, const sbp_msg_ssr_tile_definition_dep_t *msg, + sbp_write_fn_t write) { uint8_t payload[SBP_MAX_PAYLOAD_LEN]; uint8_t payload_len; - s8 ret = sbp_msg_ssr_tile_definition_encode(payload, sizeof(payload), - &payload_len, msg); + s8 ret = sbp_msg_ssr_tile_definition_dep_encode(payload, sizeof(payload), + &payload_len, msg); if (ret != SBP_OK) { return ret; } - return sbp_payload_send(s, SBP_MSG_SSR_TILE_DEFINITION, sender_id, + return sbp_payload_send(s, SBP_MSG_SSR_TILE_DEFINITION_DEP, sender_id, payload_len, payload, write); } -int sbp_msg_ssr_tile_definition_cmp(const sbp_msg_ssr_tile_definition_t *a, - const sbp_msg_ssr_tile_definition_t *b) { +int sbp_msg_ssr_tile_definition_dep_cmp( + const sbp_msg_ssr_tile_definition_dep_t *a, + const sbp_msg_ssr_tile_definition_dep_t *b) { int ret = 0; ret = sbp_u16_cmp(&a->tile_set_id, &b->tile_set_id); @@ -1721,6 +1886,87 @@ int sbp_msg_ssr_tile_definition_cmp(const sbp_msg_ssr_tile_definition_t *a, return ret; } +bool sbp_msg_ssr_tile_definition_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_tile_definition_t *msg) { + for (size_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_encode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_tile_definition_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_tile_definition_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_tile_definition_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_ssr_tile_definition_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_tile_definition_t *msg) { + msg->n_stub = (uint8_t)((ctx->buf_len - ctx->offset) / SBP_ENCODED_LEN_U8); + for (uint8_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_decode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_tile_definition_decode(const uint8_t *buf, uint8_t len, + uint8_t *n_read, + sbp_msg_ssr_tile_definition_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_tile_definition_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_ssr_tile_definition_send(sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_tile_definition_t *msg, + sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = sbp_msg_ssr_tile_definition_encode(payload, sizeof(payload), + &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_payload_send(s, SBP_MSG_SSR_TILE_DEFINITION, sender_id, + payload_len, payload, write); +} + +int sbp_msg_ssr_tile_definition_cmp(const sbp_msg_ssr_tile_definition_t *a, + const sbp_msg_ssr_tile_definition_t *b) { + int ret = 0; + + ret = sbp_u8_cmp(&a->n_stub, &b->n_stub); + for (uint8_t i = 0; ret == 0 && i < a->n_stub; i++) { + ret = sbp_u8_cmp(&a->stub[i], &b->stub[i]); + } + if (ret != 0) { + return ret; + } + return ret; +} + bool sbp_satellite_apc_encode_internal(sbp_encode_ctx_t *ctx, const sbp_satellite_apc_t *msg) { if (!sbp_v4_gnss_signal_encode_internal(ctx, &msg->sid)) { @@ -2894,3 +3140,251 @@ int sbp_msg_ssr_grid_definition_dep_a_cmp( } return ret; } + +bool sbp_msg_ssr_orbit_clock_bounds_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_orbit_clock_bounds_t *msg) { + for (size_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_encode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_orbit_clock_bounds_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_orbit_clock_bounds_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_orbit_clock_bounds_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_ssr_orbit_clock_bounds_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_orbit_clock_bounds_t *msg) { + msg->n_stub = (uint8_t)((ctx->buf_len - ctx->offset) / SBP_ENCODED_LEN_U8); + for (uint8_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_decode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_orbit_clock_bounds_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_orbit_clock_bounds_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_orbit_clock_bounds_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_ssr_orbit_clock_bounds_send( + sbp_state_t *s, u16 sender_id, const sbp_msg_ssr_orbit_clock_bounds_t *msg, + sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = sbp_msg_ssr_orbit_clock_bounds_encode(payload, sizeof(payload), + &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_payload_send(s, SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS, sender_id, + payload_len, payload, write); +} + +int sbp_msg_ssr_orbit_clock_bounds_cmp( + const sbp_msg_ssr_orbit_clock_bounds_t *a, + const sbp_msg_ssr_orbit_clock_bounds_t *b) { + int ret = 0; + + ret = sbp_u8_cmp(&a->n_stub, &b->n_stub); + for (uint8_t i = 0; ret == 0 && i < a->n_stub; i++) { + ret = sbp_u8_cmp(&a->stub[i], &b->stub[i]); + } + if (ret != 0) { + return ret; + } + return ret; +} + +bool sbp_msg_ssr_code_phase_biases_bounds_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_code_phase_biases_bounds_t *msg) { + for (size_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_encode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_code_phase_biases_bounds_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_code_phase_biases_bounds_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_code_phase_biases_bounds_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_ssr_code_phase_biases_bounds_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_code_phase_biases_bounds_t *msg) { + msg->n_stub = (uint8_t)((ctx->buf_len - ctx->offset) / SBP_ENCODED_LEN_U8); + for (uint8_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_decode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_code_phase_biases_bounds_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_code_phase_biases_bounds_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_code_phase_biases_bounds_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_ssr_code_phase_biases_bounds_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_code_phase_biases_bounds_t *msg, sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = sbp_msg_ssr_code_phase_biases_bounds_encode(payload, sizeof(payload), + &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_payload_send(s, SBP_MSG_SSR_CODE_PHASE_BIASES_BOUNDS, sender_id, + payload_len, payload, write); +} + +int sbp_msg_ssr_code_phase_biases_bounds_cmp( + const sbp_msg_ssr_code_phase_biases_bounds_t *a, + const sbp_msg_ssr_code_phase_biases_bounds_t *b) { + int ret = 0; + + ret = sbp_u8_cmp(&a->n_stub, &b->n_stub); + for (uint8_t i = 0; ret == 0 && i < a->n_stub; i++) { + ret = sbp_u8_cmp(&a->stub[i], &b->stub[i]); + } + if (ret != 0) { + return ret; + } + return ret; +} + +bool sbp_msg_ssr_orbit_clock_bounds_degradation_encode_internal( + sbp_encode_ctx_t *ctx, + const sbp_msg_ssr_orbit_clock_bounds_degradation_t *msg) { + for (size_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_encode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_orbit_clock_bounds_degradation_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_orbit_clock_bounds_degradation_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_orbit_clock_bounds_degradation_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_ssr_orbit_clock_bounds_degradation_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_orbit_clock_bounds_degradation_t *msg) { + msg->n_stub = (uint8_t)((ctx->buf_len - ctx->offset) / SBP_ENCODED_LEN_U8); + for (uint8_t i = 0; i < msg->n_stub; i++) { + if (!sbp_u8_decode(ctx, &msg->stub[i])) { + return false; + } + } + return true; +} + +s8 sbp_msg_ssr_orbit_clock_bounds_degradation_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_orbit_clock_bounds_degradation_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_orbit_clock_bounds_degradation_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_ssr_orbit_clock_bounds_degradation_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_orbit_clock_bounds_degradation_t *msg, + sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = sbp_msg_ssr_orbit_clock_bounds_degradation_encode( + payload, sizeof(payload), &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_payload_send(s, SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION, + sender_id, payload_len, payload, write); +} + +int sbp_msg_ssr_orbit_clock_bounds_degradation_cmp( + const sbp_msg_ssr_orbit_clock_bounds_degradation_t *a, + const sbp_msg_ssr_orbit_clock_bounds_degradation_t *b) { + int ret = 0; + + ret = sbp_u8_cmp(&a->n_stub, &b->n_stub); + for (uint8_t i = 0; ret == 0 && i < a->n_stub; i++) { + ret = sbp_u8_cmp(&a->stub[i], &b->stub[i]); + } + if (ret != 0) { + return ret; + } + return ret; +} diff --git a/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c b/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c new file mode 100644 index 0000000000..1173e0cb0b --- /dev/null +++ b/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c @@ -0,0 +1,359 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + sbp_msg_type_t msg_type; + sbp_msg_t msg; + void *context; +} last_msg; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static void *DUMMY_MEMORY_FOR_CALLBACKS = (void *)0xdeadbeef; +static void *DUMMY_MEMORY_FOR_IO = (void *)0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return (s32)real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return (s32)real_n; +} + +static void logging_reset() { memset(&last_msg, 0, sizeof(last_msg)); } + +static void msg_callback(u16 sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.msg_type = msg_type; + last_msg.msg = *msg; + last_msg.context = context; +} + +START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevel) { + static sbp_msg_callbacks_node_t n; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_callback_register(&sbp_state, 3001, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, + 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, 1, 2, + 3, 0, 0, 0, 0, 0, 0, 4, 5, 6, 7, 102, 67, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.ssr_flag_high_level.n_stub = 31; + + test_msg.ssr_flag_high_level.stub[0] = 180; + + test_msg.ssr_flag_high_level.stub[1] = 0; + + test_msg.ssr_flag_high_level.stub[2] = 0; + + test_msg.ssr_flag_high_level.stub[3] = 0; + + test_msg.ssr_flag_high_level.stub[4] = 3; + + test_msg.ssr_flag_high_level.stub[5] = 0; + + test_msg.ssr_flag_high_level.stub[6] = 104; + + test_msg.ssr_flag_high_level.stub[7] = 1; + + test_msg.ssr_flag_high_level.stub[8] = 0; + + test_msg.ssr_flag_high_level.stub[9] = 0; + + test_msg.ssr_flag_high_level.stub[10] = 6; + + test_msg.ssr_flag_high_level.stub[11] = 0; + + test_msg.ssr_flag_high_level.stub[12] = 10; + + test_msg.ssr_flag_high_level.stub[13] = 20; + + test_msg.ssr_flag_high_level.stub[14] = 0; + + test_msg.ssr_flag_high_level.stub[15] = 30; + + test_msg.ssr_flag_high_level.stub[16] = 0; + + test_msg.ssr_flag_high_level.stub[17] = 40; + + test_msg.ssr_flag_high_level.stub[18] = 1; + + test_msg.ssr_flag_high_level.stub[19] = 2; + + test_msg.ssr_flag_high_level.stub[20] = 3; + + test_msg.ssr_flag_high_level.stub[21] = 0; + + test_msg.ssr_flag_high_level.stub[22] = 0; + + test_msg.ssr_flag_high_level.stub[23] = 0; + + test_msg.ssr_flag_high_level.stub[24] = 0; + + test_msg.ssr_flag_high_level.stub[25] = 0; + + test_msg.ssr_flag_high_level.stub[26] = 0; + + test_msg.ssr_flag_high_level.stub[27] = 4; + + test_msg.ssr_flag_high_level.stub[28] = 5; + + test_msg.ssr_flag_high_level.stub[29] = 6; + + test_msg.ssr_flag_high_level.stub[30] = 7; + + sbp_message_send(&sbp_state, SbpMsgSsrFlagHighLevel, 66, &test_msg, + &dummy_write); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff (expected: %zu, " + "actual: %zu)", + sizeof(encoded_frame), dummy_wr); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + + ck_assert_msg( + sbp_message_cmp(SbpMsgSsrFlagHighLevel, &last_msg.msg, &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level.n_stub == 31, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level.n_stub, expected 31, is %d", + last_msg.msg.ssr_flag_high_level.n_stub); + + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[0] == 180, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[0], " + "expected 180, is %d", + last_msg.msg.ssr_flag_high_level.stub[0]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level.stub[1] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level.stub[1], expected 0, is %d", + last_msg.msg.ssr_flag_high_level.stub[1]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level.stub[2] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level.stub[2], expected 0, is %d", + last_msg.msg.ssr_flag_high_level.stub[2]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level.stub[3] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level.stub[3], expected 0, is %d", + last_msg.msg.ssr_flag_high_level.stub[3]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level.stub[4] == 3, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level.stub[4], expected 3, is %d", + last_msg.msg.ssr_flag_high_level.stub[4]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level.stub[5] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level.stub[5], expected 0, is %d", + last_msg.msg.ssr_flag_high_level.stub[5]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[6] == 104, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[6], " + "expected 104, is %d", + last_msg.msg.ssr_flag_high_level.stub[6]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level.stub[7] == 1, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level.stub[7], expected 1, is %d", + last_msg.msg.ssr_flag_high_level.stub[7]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level.stub[8] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level.stub[8], expected 0, is %d", + last_msg.msg.ssr_flag_high_level.stub[8]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level.stub[9] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level.stub[9], expected 0, is %d", + last_msg.msg.ssr_flag_high_level.stub[9]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[10] == 6, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[10], " + "expected 6, is %d", + last_msg.msg.ssr_flag_high_level.stub[10]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[11] == 0, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[11], " + "expected 0, is %d", + last_msg.msg.ssr_flag_high_level.stub[11]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[12] == 10, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[12], " + "expected 10, is %d", + last_msg.msg.ssr_flag_high_level.stub[12]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[13] == 20, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[13], " + "expected 20, is %d", + last_msg.msg.ssr_flag_high_level.stub[13]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[14] == 0, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[14], " + "expected 0, is %d", + last_msg.msg.ssr_flag_high_level.stub[14]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[15] == 30, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[15], " + "expected 30, is %d", + last_msg.msg.ssr_flag_high_level.stub[15]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[16] == 0, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[16], " + "expected 0, is %d", + last_msg.msg.ssr_flag_high_level.stub[16]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[17] == 40, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[17], " + "expected 40, is %d", + last_msg.msg.ssr_flag_high_level.stub[17]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[18] == 1, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[18], " + "expected 1, is %d", + last_msg.msg.ssr_flag_high_level.stub[18]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[19] == 2, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[19], " + "expected 2, is %d", + last_msg.msg.ssr_flag_high_level.stub[19]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[20] == 3, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[20], " + "expected 3, is %d", + last_msg.msg.ssr_flag_high_level.stub[20]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[21] == 0, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[21], " + "expected 0, is %d", + last_msg.msg.ssr_flag_high_level.stub[21]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[22] == 0, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[22], " + "expected 0, is %d", + last_msg.msg.ssr_flag_high_level.stub[22]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[23] == 0, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[23], " + "expected 0, is %d", + last_msg.msg.ssr_flag_high_level.stub[23]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[24] == 0, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[24], " + "expected 0, is %d", + last_msg.msg.ssr_flag_high_level.stub[24]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[25] == 0, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[25], " + "expected 0, is %d", + last_msg.msg.ssr_flag_high_level.stub[25]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[26] == 0, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[26], " + "expected 0, is %d", + last_msg.msg.ssr_flag_high_level.stub[26]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[27] == 4, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[27], " + "expected 4, is %d", + last_msg.msg.ssr_flag_high_level.stub[27]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[28] == 5, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[28], " + "expected 5, is %d", + last_msg.msg.ssr_flag_high_level.stub[28]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[29] == 6, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[29], " + "expected 6, is %d", + last_msg.msg.ssr_flag_high_level.stub[29]); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.stub[30] == 7, + "incorrect value for last_msg.msg.ssr_flag_high_level.stub[30], " + "expected 7, is %d", + last_msg.msg.ssr_flag_high_level.stub[30]); + } +} +END_TEST + +Suite *auto_check_sbp_integrity_MsgSsrFlagHighLevel_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: auto_check_sbp_integrity_MsgSsrFlagHighLevel"); + TCase *tc_acq = tcase_create( + "Automated_Suite_auto_check_sbp_integrity_MsgSsrFlagHighLevel"); + tcase_add_test(tc_acq, test_auto_check_sbp_integrity_MsgSsrFlagHighLevel); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos.c b/c/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos.c new file mode 100644 index 0000000000..b3a7a415f5 --- /dev/null +++ b/c/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos.c @@ -0,0 +1,299 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPointSatLos.yaml +// by generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + sbp_msg_type_t msg_type; + sbp_msg_t msg; + void *context; +} last_msg; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static void *DUMMY_MEMORY_FOR_CALLBACKS = (void *)0xdeadbeef; +static void *DUMMY_MEMORY_FOR_IO = (void *)0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return (s32)real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return (s32)real_n; +} + +static void logging_reset() { memset(&last_msg, 0, sizeof(last_msg)); } + +static void msg_callback(u16 sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.msg_type = msg_type; + last_msg.msg = *msg; + last_msg.context = context; +} + +START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos) { + static sbp_msg_callbacks_node_t n; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_callback_register(&sbp_state, 3025, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 209, 11, 66, 0, 21, 180, 0, 0, 0, 3, 0, 1, 2, 3, + 4, 0, 5, 0, 6, 30, 0, 2, 10, 11, 15, 14, 98, 148, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.ssr_flag_iono_grid_point_sat_los.n_stub = 21; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[0] = 180; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[1] = 0; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[2] = 0; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[3] = 0; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[4] = 3; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[5] = 0; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[6] = 1; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[7] = 2; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[8] = 3; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[9] = 4; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[10] = 0; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[11] = 5; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[12] = 0; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[13] = 6; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[14] = 30; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[15] = 0; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[16] = 2; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[17] = 10; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[18] = 11; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[19] = 15; + + test_msg.ssr_flag_iono_grid_point_sat_los.stub[20] = 14; + + sbp_message_send(&sbp_state, SbpMsgSsrFlagIonoGridPointSatLos, 66, + &test_msg, &dummy_write); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff (expected: %zu, " + "actual: %zu)", + sizeof(encoded_frame), dummy_wr); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + + ck_assert_msg(sbp_message_cmp(SbpMsgSsrFlagIonoGridPointSatLos, + &last_msg.msg, &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.n_stub == 21, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.n_stub, " + "expected 21, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.n_stub); + + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[0] == 180, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[0], " + "expected 180, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[0]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[1] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[1], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[1]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[2] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[2], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[2]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[3] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[3], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[3]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[4] == 3, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[4], " + "expected 3, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[4]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[5] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[5], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[5]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[6] == 1, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[6], " + "expected 1, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[6]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[7] == 2, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[7], " + "expected 2, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[7]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[8] == 3, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[8], " + "expected 3, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[8]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[9] == 4, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[9], " + "expected 4, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[9]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[10] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[10], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[10]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[11] == 5, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[11], " + "expected 5, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[11]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[12] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[12], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[12]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[13] == 6, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[13], " + "expected 6, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[13]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[14] == 30, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[14], " + "expected 30, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[14]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[15] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[15], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[15]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[16] == 2, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[16], " + "expected 2, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[16]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[17] == 10, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[17], " + "expected 10, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[17]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[18] == 11, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[18], " + "expected 11, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[18]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[19] == 15, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[19], " + "expected 15, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[19]); + ck_assert_msg(last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[20] == 14, + "incorrect value for " + "last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[20], " + "expected 14, is %d", + last_msg.msg.ssr_flag_iono_grid_point_sat_los.stub[20]); + } +} +END_TEST + +Suite *auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos"); + TCase *tc_acq = tcase_create( + "Automated_Suite_auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos"); + tcase_add_test(tc_acq, + test_auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints.c b/c/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints.c new file mode 100644 index 0000000000..b607738ffd --- /dev/null +++ b/c/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints.c @@ -0,0 +1,299 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPoints.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + sbp_msg_type_t msg_type; + sbp_msg_t msg; + void *context; +} last_msg; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static void *DUMMY_MEMORY_FOR_CALLBACKS = (void *)0xdeadbeef; +static void *DUMMY_MEMORY_FOR_IO = (void *)0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return (s32)real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return (s32)real_n; +} + +static void logging_reset() { memset(&last_msg, 0, sizeof(last_msg)); } + +static void msg_callback(u16 sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.msg_type = msg_type; + last_msg.msg = *msg; + last_msg.context = context; +} + +START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints) { + static sbp_msg_callbacks_node_t n; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_callback_register(&sbp_state, 3015, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 199, 11, 66, 0, 21, 180, 0, 0, 0, 3, 0, 1, 2, 3, + 4, 0, 5, 0, 6, 3, 10, 0, 11, 0, 12, 0, 53, 7, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.ssr_flag_iono_grid_points.n_stub = 21; + + test_msg.ssr_flag_iono_grid_points.stub[0] = 180; + + test_msg.ssr_flag_iono_grid_points.stub[1] = 0; + + test_msg.ssr_flag_iono_grid_points.stub[2] = 0; + + test_msg.ssr_flag_iono_grid_points.stub[3] = 0; + + test_msg.ssr_flag_iono_grid_points.stub[4] = 3; + + test_msg.ssr_flag_iono_grid_points.stub[5] = 0; + + test_msg.ssr_flag_iono_grid_points.stub[6] = 1; + + test_msg.ssr_flag_iono_grid_points.stub[7] = 2; + + test_msg.ssr_flag_iono_grid_points.stub[8] = 3; + + test_msg.ssr_flag_iono_grid_points.stub[9] = 4; + + test_msg.ssr_flag_iono_grid_points.stub[10] = 0; + + test_msg.ssr_flag_iono_grid_points.stub[11] = 5; + + test_msg.ssr_flag_iono_grid_points.stub[12] = 0; + + test_msg.ssr_flag_iono_grid_points.stub[13] = 6; + + test_msg.ssr_flag_iono_grid_points.stub[14] = 3; + + test_msg.ssr_flag_iono_grid_points.stub[15] = 10; + + test_msg.ssr_flag_iono_grid_points.stub[16] = 0; + + test_msg.ssr_flag_iono_grid_points.stub[17] = 11; + + test_msg.ssr_flag_iono_grid_points.stub[18] = 0; + + test_msg.ssr_flag_iono_grid_points.stub[19] = 12; + + test_msg.ssr_flag_iono_grid_points.stub[20] = 0; + + sbp_message_send(&sbp_state, SbpMsgSsrFlagIonoGridPoints, 66, &test_msg, + &dummy_write); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff (expected: %zu, " + "actual: %zu)", + sizeof(encoded_frame), dummy_wr); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + + ck_assert_msg(sbp_message_cmp(SbpMsgSsrFlagIonoGridPoints, &last_msg.msg, + &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.n_stub == 21, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.n_stub, " + "expected 21, is %d", + last_msg.msg.ssr_flag_iono_grid_points.n_stub); + + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[0] == 180, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[0], " + "expected 180, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[0]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[1] == 0, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[1], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[1]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[2] == 0, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[2], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[2]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[3] == 0, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[3], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[3]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[4] == 3, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[4], " + "expected 3, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[4]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[5] == 0, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[5], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[5]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[6] == 1, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[6], " + "expected 1, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[6]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[7] == 2, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[7], " + "expected 2, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[7]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[8] == 3, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[8], " + "expected 3, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[8]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[9] == 4, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[9], " + "expected 4, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[9]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[10] == 0, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[10], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[10]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[11] == 5, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[11], " + "expected 5, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[11]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[12] == 0, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[12], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[12]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[13] == 6, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[13], " + "expected 6, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[13]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[14] == 3, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[14], " + "expected 3, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[14]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[15] == 10, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[15], " + "expected 10, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[15]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[16] == 0, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[16], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[16]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[17] == 11, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[17], " + "expected 11, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[17]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[18] == 0, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[18], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[18]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[19] == 12, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[19], " + "expected 12, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[19]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_grid_points.stub[20] == 0, + "incorrect value for last_msg.msg.ssr_flag_iono_grid_points.stub[20], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_grid_points.stub[20]); + } +} +END_TEST + +Suite *auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints"); + TCase *tc_acq = tcase_create( + "Automated_Suite_auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints"); + tcase_add_test(tc_acq, + test_auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos.c b/c/test/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos.c new file mode 100644 index 0000000000..d89531a89b --- /dev/null +++ b/c/test/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos.c @@ -0,0 +1,285 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoTileSatLos.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + sbp_msg_type_t msg_type; + sbp_msg_t msg; + void *context; +} last_msg; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static void *DUMMY_MEMORY_FOR_CALLBACKS = (void *)0xdeadbeef; +static void *DUMMY_MEMORY_FOR_IO = (void *)0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return (s32)real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return (s32)real_n; +} + +static void logging_reset() { memset(&last_msg, 0, sizeof(last_msg)); } + +static void msg_callback(u16 sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.msg_type = msg_type; + last_msg.msg = *msg; + last_msg.context = context; +} + +START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos) { + static sbp_msg_callbacks_node_t n; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_callback_register(&sbp_state, 3021, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 205, 11, 66, 0, 19, 180, 0, 0, 0, 3, 0, 1, 2, + 3, 4, 0, 5, 0, 6, 2, 10, 11, 15, 14, 239, 235, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.ssr_flag_iono_tile_sat_los.n_stub = 19; + + test_msg.ssr_flag_iono_tile_sat_los.stub[0] = 180; + + test_msg.ssr_flag_iono_tile_sat_los.stub[1] = 0; + + test_msg.ssr_flag_iono_tile_sat_los.stub[2] = 0; + + test_msg.ssr_flag_iono_tile_sat_los.stub[3] = 0; + + test_msg.ssr_flag_iono_tile_sat_los.stub[4] = 3; + + test_msg.ssr_flag_iono_tile_sat_los.stub[5] = 0; + + test_msg.ssr_flag_iono_tile_sat_los.stub[6] = 1; + + test_msg.ssr_flag_iono_tile_sat_los.stub[7] = 2; + + test_msg.ssr_flag_iono_tile_sat_los.stub[8] = 3; + + test_msg.ssr_flag_iono_tile_sat_los.stub[9] = 4; + + test_msg.ssr_flag_iono_tile_sat_los.stub[10] = 0; + + test_msg.ssr_flag_iono_tile_sat_los.stub[11] = 5; + + test_msg.ssr_flag_iono_tile_sat_los.stub[12] = 0; + + test_msg.ssr_flag_iono_tile_sat_los.stub[13] = 6; + + test_msg.ssr_flag_iono_tile_sat_los.stub[14] = 2; + + test_msg.ssr_flag_iono_tile_sat_los.stub[15] = 10; + + test_msg.ssr_flag_iono_tile_sat_los.stub[16] = 11; + + test_msg.ssr_flag_iono_tile_sat_los.stub[17] = 15; + + test_msg.ssr_flag_iono_tile_sat_los.stub[18] = 14; + + sbp_message_send(&sbp_state, SbpMsgSsrFlagIonoTileSatLos, 66, &test_msg, + &dummy_write); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff (expected: %zu, " + "actual: %zu)", + sizeof(encoded_frame), dummy_wr); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + + ck_assert_msg(sbp_message_cmp(SbpMsgSsrFlagIonoTileSatLos, &last_msg.msg, + &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.n_stub == 19, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.n_stub, " + "expected 19, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.n_stub); + + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[0] == 180, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[0], " + "expected 180, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[0]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[1] == 0, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[1], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[1]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[2] == 0, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[2], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[2]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[3] == 0, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[3], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[3]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[4] == 3, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[4], " + "expected 3, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[4]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[5] == 0, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[5], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[5]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[6] == 1, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[6], " + "expected 1, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[6]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[7] == 2, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[7], " + "expected 2, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[7]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[8] == 3, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[8], " + "expected 3, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[8]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[9] == 4, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[9], " + "expected 4, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[9]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[10] == 0, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[10], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[10]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[11] == 5, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[11], " + "expected 5, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[11]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[12] == 0, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[12], " + "expected 0, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[12]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[13] == 6, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[13], " + "expected 6, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[13]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[14] == 2, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[14], " + "expected 2, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[14]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[15] == 10, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[15], " + "expected 10, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[15]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[16] == 11, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[16], " + "expected 11, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[16]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[17] == 15, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[17], " + "expected 15, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[17]); + ck_assert_msg( + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[18] == 14, + "incorrect value for last_msg.msg.ssr_flag_iono_tile_sat_los.stub[18], " + "expected 14, is %d", + last_msg.msg.ssr_flag_iono_tile_sat_los.stub[18]); + } +} +END_TEST + +Suite *auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos"); + TCase *tc_acq = tcase_create( + "Automated_Suite_auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos"); + tcase_add_test(tc_acq, + test_auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/auto_check_sbp_integrity_MsgSsrFlagSatellites.c b/c/test/auto_check_sbp_integrity_MsgSsrFlagSatellites.c new file mode 100644 index 0000000000..90c4d5896f --- /dev/null +++ b/c/test/auto_check_sbp_integrity_MsgSsrFlagSatellites.c @@ -0,0 +1,246 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagSatellites.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + sbp_msg_type_t msg_type; + sbp_msg_t msg; + void *context; +} last_msg; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static void *DUMMY_MEMORY_FOR_CALLBACKS = (void *)0xdeadbeef; +static void *DUMMY_MEMORY_FOR_IO = (void *)0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return (s32)real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return (s32)real_n; +} + +static void logging_reset() { memset(&last_msg, 0, sizeof(last_msg)); } + +static void msg_callback(u16 sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.msg_type = msg_type; + last_msg.msg = *msg; + last_msg.context = context; +} + +START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagSatellites) { + static sbp_msg_callbacks_node_t n; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_callback_register(&sbp_state, 3005, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 189, 11, 66, 0, 15, 180, 0, 0, 0, 3, 0, + 1, 2, 3, 4, 5, 3, 10, 11, 12, 110, 165, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.ssr_flag_satellites.n_stub = 15; + + test_msg.ssr_flag_satellites.stub[0] = 180; + + test_msg.ssr_flag_satellites.stub[1] = 0; + + test_msg.ssr_flag_satellites.stub[2] = 0; + + test_msg.ssr_flag_satellites.stub[3] = 0; + + test_msg.ssr_flag_satellites.stub[4] = 3; + + test_msg.ssr_flag_satellites.stub[5] = 0; + + test_msg.ssr_flag_satellites.stub[6] = 1; + + test_msg.ssr_flag_satellites.stub[7] = 2; + + test_msg.ssr_flag_satellites.stub[8] = 3; + + test_msg.ssr_flag_satellites.stub[9] = 4; + + test_msg.ssr_flag_satellites.stub[10] = 5; + + test_msg.ssr_flag_satellites.stub[11] = 3; + + test_msg.ssr_flag_satellites.stub[12] = 10; + + test_msg.ssr_flag_satellites.stub[13] = 11; + + test_msg.ssr_flag_satellites.stub[14] = 12; + + sbp_message_send(&sbp_state, SbpMsgSsrFlagSatellites, 66, &test_msg, + &dummy_write); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff (expected: %zu, " + "actual: %zu)", + sizeof(encoded_frame), dummy_wr); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + + ck_assert_msg( + sbp_message_cmp(SbpMsgSsrFlagSatellites, &last_msg.msg, &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg(last_msg.msg.ssr_flag_satellites.n_stub == 15, + "incorrect value for " + "last_msg.msg.ssr_flag_satellites.n_stub, expected 15, is %d", + last_msg.msg.ssr_flag_satellites.n_stub); + + ck_assert_msg( + last_msg.msg.ssr_flag_satellites.stub[0] == 180, + "incorrect value for last_msg.msg.ssr_flag_satellites.stub[0], " + "expected 180, is %d", + last_msg.msg.ssr_flag_satellites.stub[0]); + ck_assert_msg(last_msg.msg.ssr_flag_satellites.stub[1] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_satellites.stub[1], expected 0, is %d", + last_msg.msg.ssr_flag_satellites.stub[1]); + ck_assert_msg(last_msg.msg.ssr_flag_satellites.stub[2] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_satellites.stub[2], expected 0, is %d", + last_msg.msg.ssr_flag_satellites.stub[2]); + ck_assert_msg(last_msg.msg.ssr_flag_satellites.stub[3] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_satellites.stub[3], expected 0, is %d", + last_msg.msg.ssr_flag_satellites.stub[3]); + ck_assert_msg(last_msg.msg.ssr_flag_satellites.stub[4] == 3, + "incorrect value for " + "last_msg.msg.ssr_flag_satellites.stub[4], expected 3, is %d", + last_msg.msg.ssr_flag_satellites.stub[4]); + ck_assert_msg(last_msg.msg.ssr_flag_satellites.stub[5] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_satellites.stub[5], expected 0, is %d", + last_msg.msg.ssr_flag_satellites.stub[5]); + ck_assert_msg(last_msg.msg.ssr_flag_satellites.stub[6] == 1, + "incorrect value for " + "last_msg.msg.ssr_flag_satellites.stub[6], expected 1, is %d", + last_msg.msg.ssr_flag_satellites.stub[6]); + ck_assert_msg(last_msg.msg.ssr_flag_satellites.stub[7] == 2, + "incorrect value for " + "last_msg.msg.ssr_flag_satellites.stub[7], expected 2, is %d", + last_msg.msg.ssr_flag_satellites.stub[7]); + ck_assert_msg(last_msg.msg.ssr_flag_satellites.stub[8] == 3, + "incorrect value for " + "last_msg.msg.ssr_flag_satellites.stub[8], expected 3, is %d", + last_msg.msg.ssr_flag_satellites.stub[8]); + ck_assert_msg(last_msg.msg.ssr_flag_satellites.stub[9] == 4, + "incorrect value for " + "last_msg.msg.ssr_flag_satellites.stub[9], expected 4, is %d", + last_msg.msg.ssr_flag_satellites.stub[9]); + ck_assert_msg( + last_msg.msg.ssr_flag_satellites.stub[10] == 5, + "incorrect value for last_msg.msg.ssr_flag_satellites.stub[10], " + "expected 5, is %d", + last_msg.msg.ssr_flag_satellites.stub[10]); + ck_assert_msg( + last_msg.msg.ssr_flag_satellites.stub[11] == 3, + "incorrect value for last_msg.msg.ssr_flag_satellites.stub[11], " + "expected 3, is %d", + last_msg.msg.ssr_flag_satellites.stub[11]); + ck_assert_msg( + last_msg.msg.ssr_flag_satellites.stub[12] == 10, + "incorrect value for last_msg.msg.ssr_flag_satellites.stub[12], " + "expected 10, is %d", + last_msg.msg.ssr_flag_satellites.stub[12]); + ck_assert_msg( + last_msg.msg.ssr_flag_satellites.stub[13] == 11, + "incorrect value for last_msg.msg.ssr_flag_satellites.stub[13], " + "expected 11, is %d", + last_msg.msg.ssr_flag_satellites.stub[13]); + ck_assert_msg( + last_msg.msg.ssr_flag_satellites.stub[14] == 12, + "incorrect value for last_msg.msg.ssr_flag_satellites.stub[14], " + "expected 12, is %d", + last_msg.msg.ssr_flag_satellites.stub[14]); + } +} +END_TEST + +Suite *auto_check_sbp_integrity_MsgSsrFlagSatellites_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "auto_check_sbp_integrity_MsgSsrFlagSatellites"); + TCase *tc_acq = tcase_create( + "Automated_Suite_auto_check_sbp_integrity_MsgSsrFlagSatellites"); + tcase_add_test(tc_acq, test_auto_check_sbp_integrity_MsgSsrFlagSatellites); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints.c b/c/test/auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints.c new file mode 100644 index 0000000000..71c6a47e00 --- /dev/null +++ b/c/test/auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints.c @@ -0,0 +1,299 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagTropoGridPoints.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + sbp_msg_type_t msg_type; + sbp_msg_t msg; + void *context; +} last_msg; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static void *DUMMY_MEMORY_FOR_CALLBACKS = (void *)0xdeadbeef; +static void *DUMMY_MEMORY_FOR_IO = (void *)0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return (s32)real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return (s32)real_n; +} + +static void logging_reset() { memset(&last_msg, 0, sizeof(last_msg)); } + +static void msg_callback(u16 sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.msg_type = msg_type; + last_msg.msg = *msg; + last_msg.context = context; +} + +START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints) { + static sbp_msg_callbacks_node_t n; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_callback_register(&sbp_state, 3011, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 195, 11, 66, 0, 21, 180, 0, 0, 0, 3, 0, 1, 2, 3, + 4, 0, 5, 0, 6, 3, 10, 0, 11, 0, 12, 0, 243, 150, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.ssr_flag_tropo_grid_points.n_stub = 21; + + test_msg.ssr_flag_tropo_grid_points.stub[0] = 180; + + test_msg.ssr_flag_tropo_grid_points.stub[1] = 0; + + test_msg.ssr_flag_tropo_grid_points.stub[2] = 0; + + test_msg.ssr_flag_tropo_grid_points.stub[3] = 0; + + test_msg.ssr_flag_tropo_grid_points.stub[4] = 3; + + test_msg.ssr_flag_tropo_grid_points.stub[5] = 0; + + test_msg.ssr_flag_tropo_grid_points.stub[6] = 1; + + test_msg.ssr_flag_tropo_grid_points.stub[7] = 2; + + test_msg.ssr_flag_tropo_grid_points.stub[8] = 3; + + test_msg.ssr_flag_tropo_grid_points.stub[9] = 4; + + test_msg.ssr_flag_tropo_grid_points.stub[10] = 0; + + test_msg.ssr_flag_tropo_grid_points.stub[11] = 5; + + test_msg.ssr_flag_tropo_grid_points.stub[12] = 0; + + test_msg.ssr_flag_tropo_grid_points.stub[13] = 6; + + test_msg.ssr_flag_tropo_grid_points.stub[14] = 3; + + test_msg.ssr_flag_tropo_grid_points.stub[15] = 10; + + test_msg.ssr_flag_tropo_grid_points.stub[16] = 0; + + test_msg.ssr_flag_tropo_grid_points.stub[17] = 11; + + test_msg.ssr_flag_tropo_grid_points.stub[18] = 0; + + test_msg.ssr_flag_tropo_grid_points.stub[19] = 12; + + test_msg.ssr_flag_tropo_grid_points.stub[20] = 0; + + sbp_message_send(&sbp_state, SbpMsgSsrFlagTropoGridPoints, 66, &test_msg, + &dummy_write); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff (expected: %zu, " + "actual: %zu)", + sizeof(encoded_frame), dummy_wr); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + + ck_assert_msg(sbp_message_cmp(SbpMsgSsrFlagTropoGridPoints, &last_msg.msg, + &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.n_stub == 21, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.n_stub, " + "expected 21, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.n_stub); + + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[0] == 180, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[0], " + "expected 180, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[0]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[1] == 0, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[1], " + "expected 0, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[1]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[2] == 0, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[2], " + "expected 0, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[2]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[3] == 0, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[3], " + "expected 0, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[3]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[4] == 3, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[4], " + "expected 3, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[4]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[5] == 0, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[5], " + "expected 0, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[5]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[6] == 1, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[6], " + "expected 1, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[6]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[7] == 2, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[7], " + "expected 2, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[7]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[8] == 3, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[8], " + "expected 3, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[8]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[9] == 4, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[9], " + "expected 4, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[9]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[10] == 0, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[10], " + "expected 0, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[10]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[11] == 5, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[11], " + "expected 5, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[11]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[12] == 0, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[12], " + "expected 0, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[12]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[13] == 6, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[13], " + "expected 6, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[13]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[14] == 3, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[14], " + "expected 3, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[14]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[15] == 10, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[15], " + "expected 10, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[15]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[16] == 0, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[16], " + "expected 0, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[16]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[17] == 11, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[17], " + "expected 11, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[17]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[18] == 0, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[18], " + "expected 0, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[18]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[19] == 12, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[19], " + "expected 12, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[19]); + ck_assert_msg( + last_msg.msg.ssr_flag_tropo_grid_points.stub[20] == 0, + "incorrect value for last_msg.msg.ssr_flag_tropo_grid_points.stub[20], " + "expected 0, is %d", + last_msg.msg.ssr_flag_tropo_grid_points.stub[20]); + } +} +END_TEST + +Suite *auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints"); + TCase *tc_acq = tcase_create( + "Automated_Suite_auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints"); + tcase_add_test(tc_acq, + test_auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/auto_check_sbp_navigation_MsgGPSLeapSecond.c b/c/test/auto_check_sbp_navigation_MsgGPSLeapSecond.c new file mode 100644 index 0000000000..0cea9c235d --- /dev/null +++ b/c/test/auto_check_sbp_navigation_MsgGPSLeapSecond.c @@ -0,0 +1,232 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSLeapSecond.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + sbp_msg_type_t msg_type; + sbp_msg_t msg; + void *context; +} last_msg; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static void *DUMMY_MEMORY_FOR_CALLBACKS = (void *)0xdeadbeef; +static void *DUMMY_MEMORY_FOR_IO = (void *)0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return (s32)real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return (s32)real_n; +} + +static void logging_reset() { memset(&last_msg, 0, sizeof(last_msg)); } + +static void msg_callback(u16 sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.msg_type = msg_type; + last_msg.msg = *msg; + last_msg.context = context; +} + +START_TEST(test_auto_check_sbp_navigation_MsgGPSLeapSecond) { + static sbp_msg_callbacks_node_t n; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_callback_register(&sbp_state, 570, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 58, 2, 66, 0, 14, 1, 0, 2, 0, 3, 4, 5, 0, 6, 0, 7, 0, 8, 9, 50, 232, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.gps_leap_second.n_stub = 14; + + test_msg.gps_leap_second.stub[0] = 1; + + test_msg.gps_leap_second.stub[1] = 0; + + test_msg.gps_leap_second.stub[2] = 2; + + test_msg.gps_leap_second.stub[3] = 0; + + test_msg.gps_leap_second.stub[4] = 3; + + test_msg.gps_leap_second.stub[5] = 4; + + test_msg.gps_leap_second.stub[6] = 5; + + test_msg.gps_leap_second.stub[7] = 0; + + test_msg.gps_leap_second.stub[8] = 6; + + test_msg.gps_leap_second.stub[9] = 0; + + test_msg.gps_leap_second.stub[10] = 7; + + test_msg.gps_leap_second.stub[11] = 0; + + test_msg.gps_leap_second.stub[12] = 8; + + test_msg.gps_leap_second.stub[13] = 9; + + sbp_message_send(&sbp_state, SbpMsgGpsLeapSecond, 66, &test_msg, + &dummy_write); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff (expected: %zu, " + "actual: %zu)", + sizeof(encoded_frame), dummy_wr); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + + ck_assert_msg( + sbp_message_cmp(SbpMsgGpsLeapSecond, &last_msg.msg, &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg(last_msg.msg.gps_leap_second.n_stub == 14, + "incorrect value for last_msg.msg.gps_leap_second.n_stub, " + "expected 14, is %d", + last_msg.msg.gps_leap_second.n_stub); + + ck_assert_msg(last_msg.msg.gps_leap_second.stub[0] == 1, + "incorrect value for last_msg.msg.gps_leap_second.stub[0], " + "expected 1, is %d", + last_msg.msg.gps_leap_second.stub[0]); + ck_assert_msg(last_msg.msg.gps_leap_second.stub[1] == 0, + "incorrect value for last_msg.msg.gps_leap_second.stub[1], " + "expected 0, is %d", + last_msg.msg.gps_leap_second.stub[1]); + ck_assert_msg(last_msg.msg.gps_leap_second.stub[2] == 2, + "incorrect value for last_msg.msg.gps_leap_second.stub[2], " + "expected 2, is %d", + last_msg.msg.gps_leap_second.stub[2]); + ck_assert_msg(last_msg.msg.gps_leap_second.stub[3] == 0, + "incorrect value for last_msg.msg.gps_leap_second.stub[3], " + "expected 0, is %d", + last_msg.msg.gps_leap_second.stub[3]); + ck_assert_msg(last_msg.msg.gps_leap_second.stub[4] == 3, + "incorrect value for last_msg.msg.gps_leap_second.stub[4], " + "expected 3, is %d", + last_msg.msg.gps_leap_second.stub[4]); + ck_assert_msg(last_msg.msg.gps_leap_second.stub[5] == 4, + "incorrect value for last_msg.msg.gps_leap_second.stub[5], " + "expected 4, is %d", + last_msg.msg.gps_leap_second.stub[5]); + ck_assert_msg(last_msg.msg.gps_leap_second.stub[6] == 5, + "incorrect value for last_msg.msg.gps_leap_second.stub[6], " + "expected 5, is %d", + last_msg.msg.gps_leap_second.stub[6]); + ck_assert_msg(last_msg.msg.gps_leap_second.stub[7] == 0, + "incorrect value for last_msg.msg.gps_leap_second.stub[7], " + "expected 0, is %d", + last_msg.msg.gps_leap_second.stub[7]); + ck_assert_msg(last_msg.msg.gps_leap_second.stub[8] == 6, + "incorrect value for last_msg.msg.gps_leap_second.stub[8], " + "expected 6, is %d", + last_msg.msg.gps_leap_second.stub[8]); + ck_assert_msg(last_msg.msg.gps_leap_second.stub[9] == 0, + "incorrect value for last_msg.msg.gps_leap_second.stub[9], " + "expected 0, is %d", + last_msg.msg.gps_leap_second.stub[9]); + ck_assert_msg(last_msg.msg.gps_leap_second.stub[10] == 7, + "incorrect value for last_msg.msg.gps_leap_second.stub[10], " + "expected 7, is %d", + last_msg.msg.gps_leap_second.stub[10]); + ck_assert_msg(last_msg.msg.gps_leap_second.stub[11] == 0, + "incorrect value for last_msg.msg.gps_leap_second.stub[11], " + "expected 0, is %d", + last_msg.msg.gps_leap_second.stub[11]); + ck_assert_msg(last_msg.msg.gps_leap_second.stub[12] == 8, + "incorrect value for last_msg.msg.gps_leap_second.stub[12], " + "expected 8, is %d", + last_msg.msg.gps_leap_second.stub[12]); + ck_assert_msg(last_msg.msg.gps_leap_second.stub[13] == 9, + "incorrect value for last_msg.msg.gps_leap_second.stub[13], " + "expected 9, is %d", + last_msg.msg.gps_leap_second.stub[13]); + } +} +END_TEST + +Suite *auto_check_sbp_navigation_MsgGPSLeapSecond_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: auto_check_sbp_navigation_MsgGPSLeapSecond"); + TCase *tc_acq = tcase_create( + "Automated_Suite_auto_check_sbp_navigation_MsgGPSLeapSecond"); + tcase_add_test(tc_acq, test_auto_check_sbp_navigation_MsgGPSLeapSecond); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/auto_check_sbp_navigation_MsgItrf.c b/c/test/auto_check_sbp_navigation_MsgItrf.c new file mode 100644 index 0000000000..47d1f7bdac --- /dev/null +++ b/c/test/auto_check_sbp_navigation_MsgItrf.c @@ -0,0 +1,897 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml by generate.py. Do +// not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + sbp_msg_type_t msg_type; + sbp_msg_t msg; + void *context; +} last_msg; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static void *DUMMY_MEMORY_FOR_CALLBACKS = (void *)0xdeadbeef; +static void *DUMMY_MEMORY_FOR_IO = (void *)0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return (s32)real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return (s32)real_n; +} + +static void logging_reset() { memset(&last_msg, 0, sizeof(last_msg)); } + +static void msg_callback(u16 sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.msg_type = msg_type; + last_msg.msg = *msg; + last_msg.context = context; +} + +START_TEST(test_auto_check_sbp_navigation_MsgItrf) { + static sbp_msg_callbacks_node_t n; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_callback_register(&sbp_state, 580, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 68, 2, 66, 0, 124, 1, 2, 102, 111, 111, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 98, 97, 114, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 5, 0, 6, 0, 7, 0, 0, 0, 8, 0, 0, 0, 9, + 0, 0, 0, 10, 0, 0, 0, 11, 0, 0, 0, 12, 0, 0, 0, 13, 0, + 0, 0, 14, 0, 0, 0, 15, 0, 0, 0, 16, 0, 0, 0, 17, 0, 0, + 0, 18, 0, 0, 0, 19, 0, 0, 0, 20, 0, 66, 126, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.itrf.n_stub = 124; + + test_msg.itrf.stub[0] = 1; + + test_msg.itrf.stub[1] = 2; + + test_msg.itrf.stub[2] = 102; + + test_msg.itrf.stub[3] = 111; + + test_msg.itrf.stub[4] = 111; + + test_msg.itrf.stub[5] = 0; + + test_msg.itrf.stub[6] = 0; + + test_msg.itrf.stub[7] = 0; + + test_msg.itrf.stub[8] = 0; + + test_msg.itrf.stub[9] = 0; + + test_msg.itrf.stub[10] = 0; + + test_msg.itrf.stub[11] = 0; + + test_msg.itrf.stub[12] = 0; + + test_msg.itrf.stub[13] = 0; + + test_msg.itrf.stub[14] = 0; + + test_msg.itrf.stub[15] = 0; + + test_msg.itrf.stub[16] = 0; + + test_msg.itrf.stub[17] = 0; + + test_msg.itrf.stub[18] = 0; + + test_msg.itrf.stub[19] = 0; + + test_msg.itrf.stub[20] = 0; + + test_msg.itrf.stub[21] = 0; + + test_msg.itrf.stub[22] = 0; + + test_msg.itrf.stub[23] = 0; + + test_msg.itrf.stub[24] = 0; + + test_msg.itrf.stub[25] = 0; + + test_msg.itrf.stub[26] = 0; + + test_msg.itrf.stub[27] = 0; + + test_msg.itrf.stub[28] = 0; + + test_msg.itrf.stub[29] = 0; + + test_msg.itrf.stub[30] = 0; + + test_msg.itrf.stub[31] = 0; + + test_msg.itrf.stub[32] = 0; + + test_msg.itrf.stub[33] = 3; + + test_msg.itrf.stub[34] = 98; + + test_msg.itrf.stub[35] = 97; + + test_msg.itrf.stub[36] = 114; + + test_msg.itrf.stub[37] = 0; + + test_msg.itrf.stub[38] = 0; + + test_msg.itrf.stub[39] = 0; + + test_msg.itrf.stub[40] = 0; + + test_msg.itrf.stub[41] = 0; + + test_msg.itrf.stub[42] = 0; + + test_msg.itrf.stub[43] = 0; + + test_msg.itrf.stub[44] = 0; + + test_msg.itrf.stub[45] = 0; + + test_msg.itrf.stub[46] = 0; + + test_msg.itrf.stub[47] = 0; + + test_msg.itrf.stub[48] = 0; + + test_msg.itrf.stub[49] = 0; + + test_msg.itrf.stub[50] = 0; + + test_msg.itrf.stub[51] = 0; + + test_msg.itrf.stub[52] = 0; + + test_msg.itrf.stub[53] = 0; + + test_msg.itrf.stub[54] = 0; + + test_msg.itrf.stub[55] = 0; + + test_msg.itrf.stub[56] = 0; + + test_msg.itrf.stub[57] = 0; + + test_msg.itrf.stub[58] = 0; + + test_msg.itrf.stub[59] = 0; + + test_msg.itrf.stub[60] = 0; + + test_msg.itrf.stub[61] = 0; + + test_msg.itrf.stub[62] = 0; + + test_msg.itrf.stub[63] = 0; + + test_msg.itrf.stub[64] = 0; + + test_msg.itrf.stub[65] = 4; + + test_msg.itrf.stub[66] = 5; + + test_msg.itrf.stub[67] = 0; + + test_msg.itrf.stub[68] = 6; + + test_msg.itrf.stub[69] = 0; + + test_msg.itrf.stub[70] = 7; + + test_msg.itrf.stub[71] = 0; + + test_msg.itrf.stub[72] = 0; + + test_msg.itrf.stub[73] = 0; + + test_msg.itrf.stub[74] = 8; + + test_msg.itrf.stub[75] = 0; + + test_msg.itrf.stub[76] = 0; + + test_msg.itrf.stub[77] = 0; + + test_msg.itrf.stub[78] = 9; + + test_msg.itrf.stub[79] = 0; + + test_msg.itrf.stub[80] = 0; + + test_msg.itrf.stub[81] = 0; + + test_msg.itrf.stub[82] = 10; + + test_msg.itrf.stub[83] = 0; + + test_msg.itrf.stub[84] = 0; + + test_msg.itrf.stub[85] = 0; + + test_msg.itrf.stub[86] = 11; + + test_msg.itrf.stub[87] = 0; + + test_msg.itrf.stub[88] = 0; + + test_msg.itrf.stub[89] = 0; + + test_msg.itrf.stub[90] = 12; + + test_msg.itrf.stub[91] = 0; + + test_msg.itrf.stub[92] = 0; + + test_msg.itrf.stub[93] = 0; + + test_msg.itrf.stub[94] = 13; + + test_msg.itrf.stub[95] = 0; + + test_msg.itrf.stub[96] = 0; + + test_msg.itrf.stub[97] = 0; + + test_msg.itrf.stub[98] = 14; + + test_msg.itrf.stub[99] = 0; + + test_msg.itrf.stub[100] = 0; + + test_msg.itrf.stub[101] = 0; + + test_msg.itrf.stub[102] = 15; + + test_msg.itrf.stub[103] = 0; + + test_msg.itrf.stub[104] = 0; + + test_msg.itrf.stub[105] = 0; + + test_msg.itrf.stub[106] = 16; + + test_msg.itrf.stub[107] = 0; + + test_msg.itrf.stub[108] = 0; + + test_msg.itrf.stub[109] = 0; + + test_msg.itrf.stub[110] = 17; + + test_msg.itrf.stub[111] = 0; + + test_msg.itrf.stub[112] = 0; + + test_msg.itrf.stub[113] = 0; + + test_msg.itrf.stub[114] = 18; + + test_msg.itrf.stub[115] = 0; + + test_msg.itrf.stub[116] = 0; + + test_msg.itrf.stub[117] = 0; + + test_msg.itrf.stub[118] = 19; + + test_msg.itrf.stub[119] = 0; + + test_msg.itrf.stub[120] = 0; + + test_msg.itrf.stub[121] = 0; + + test_msg.itrf.stub[122] = 20; + + test_msg.itrf.stub[123] = 0; + + sbp_message_send(&sbp_state, SbpMsgItrf, 66, &test_msg, &dummy_write); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff (expected: %zu, " + "actual: %zu)", + sizeof(encoded_frame), dummy_wr); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + + ck_assert_msg(sbp_message_cmp(SbpMsgItrf, &last_msg.msg, &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg( + last_msg.msg.itrf.n_stub == 124, + "incorrect value for last_msg.msg.itrf.n_stub, expected 124, is %d", + last_msg.msg.itrf.n_stub); + + ck_assert_msg( + last_msg.msg.itrf.stub[0] == 1, + "incorrect value for last_msg.msg.itrf.stub[0], expected 1, is %d", + last_msg.msg.itrf.stub[0]); + ck_assert_msg( + last_msg.msg.itrf.stub[1] == 2, + "incorrect value for last_msg.msg.itrf.stub[1], expected 2, is %d", + last_msg.msg.itrf.stub[1]); + ck_assert_msg( + last_msg.msg.itrf.stub[2] == 102, + "incorrect value for last_msg.msg.itrf.stub[2], expected 102, is %d", + last_msg.msg.itrf.stub[2]); + ck_assert_msg( + last_msg.msg.itrf.stub[3] == 111, + "incorrect value for last_msg.msg.itrf.stub[3], expected 111, is %d", + last_msg.msg.itrf.stub[3]); + ck_assert_msg( + last_msg.msg.itrf.stub[4] == 111, + "incorrect value for last_msg.msg.itrf.stub[4], expected 111, is %d", + last_msg.msg.itrf.stub[4]); + ck_assert_msg( + last_msg.msg.itrf.stub[5] == 0, + "incorrect value for last_msg.msg.itrf.stub[5], expected 0, is %d", + last_msg.msg.itrf.stub[5]); + ck_assert_msg( + last_msg.msg.itrf.stub[6] == 0, + "incorrect value for last_msg.msg.itrf.stub[6], expected 0, is %d", + last_msg.msg.itrf.stub[6]); + ck_assert_msg( + last_msg.msg.itrf.stub[7] == 0, + "incorrect value for last_msg.msg.itrf.stub[7], expected 0, is %d", + last_msg.msg.itrf.stub[7]); + ck_assert_msg( + last_msg.msg.itrf.stub[8] == 0, + "incorrect value for last_msg.msg.itrf.stub[8], expected 0, is %d", + last_msg.msg.itrf.stub[8]); + ck_assert_msg( + last_msg.msg.itrf.stub[9] == 0, + "incorrect value for last_msg.msg.itrf.stub[9], expected 0, is %d", + last_msg.msg.itrf.stub[9]); + ck_assert_msg( + last_msg.msg.itrf.stub[10] == 0, + "incorrect value for last_msg.msg.itrf.stub[10], expected 0, is %d", + last_msg.msg.itrf.stub[10]); + ck_assert_msg( + last_msg.msg.itrf.stub[11] == 0, + "incorrect value for last_msg.msg.itrf.stub[11], expected 0, is %d", + last_msg.msg.itrf.stub[11]); + ck_assert_msg( + last_msg.msg.itrf.stub[12] == 0, + "incorrect value for last_msg.msg.itrf.stub[12], expected 0, is %d", + last_msg.msg.itrf.stub[12]); + ck_assert_msg( + last_msg.msg.itrf.stub[13] == 0, + "incorrect value for last_msg.msg.itrf.stub[13], expected 0, is %d", + last_msg.msg.itrf.stub[13]); + ck_assert_msg( + last_msg.msg.itrf.stub[14] == 0, + "incorrect value for last_msg.msg.itrf.stub[14], expected 0, is %d", + last_msg.msg.itrf.stub[14]); + ck_assert_msg( + last_msg.msg.itrf.stub[15] == 0, + "incorrect value for last_msg.msg.itrf.stub[15], expected 0, is %d", + last_msg.msg.itrf.stub[15]); + ck_assert_msg( + last_msg.msg.itrf.stub[16] == 0, + "incorrect value for last_msg.msg.itrf.stub[16], expected 0, is %d", + last_msg.msg.itrf.stub[16]); + ck_assert_msg( + last_msg.msg.itrf.stub[17] == 0, + "incorrect value for last_msg.msg.itrf.stub[17], expected 0, is %d", + last_msg.msg.itrf.stub[17]); + ck_assert_msg( + last_msg.msg.itrf.stub[18] == 0, + "incorrect value for last_msg.msg.itrf.stub[18], expected 0, is %d", + last_msg.msg.itrf.stub[18]); + ck_assert_msg( + last_msg.msg.itrf.stub[19] == 0, + "incorrect value for last_msg.msg.itrf.stub[19], expected 0, is %d", + last_msg.msg.itrf.stub[19]); + ck_assert_msg( + last_msg.msg.itrf.stub[20] == 0, + "incorrect value for last_msg.msg.itrf.stub[20], expected 0, is %d", + last_msg.msg.itrf.stub[20]); + ck_assert_msg( + last_msg.msg.itrf.stub[21] == 0, + "incorrect value for last_msg.msg.itrf.stub[21], expected 0, is %d", + last_msg.msg.itrf.stub[21]); + ck_assert_msg( + last_msg.msg.itrf.stub[22] == 0, + "incorrect value for last_msg.msg.itrf.stub[22], expected 0, is %d", + last_msg.msg.itrf.stub[22]); + ck_assert_msg( + last_msg.msg.itrf.stub[23] == 0, + "incorrect value for last_msg.msg.itrf.stub[23], expected 0, is %d", + last_msg.msg.itrf.stub[23]); + ck_assert_msg( + last_msg.msg.itrf.stub[24] == 0, + "incorrect value for last_msg.msg.itrf.stub[24], expected 0, is %d", + last_msg.msg.itrf.stub[24]); + ck_assert_msg( + last_msg.msg.itrf.stub[25] == 0, + "incorrect value for last_msg.msg.itrf.stub[25], expected 0, is %d", + last_msg.msg.itrf.stub[25]); + ck_assert_msg( + last_msg.msg.itrf.stub[26] == 0, + "incorrect value for last_msg.msg.itrf.stub[26], expected 0, is %d", + last_msg.msg.itrf.stub[26]); + ck_assert_msg( + last_msg.msg.itrf.stub[27] == 0, + "incorrect value for last_msg.msg.itrf.stub[27], expected 0, is %d", + last_msg.msg.itrf.stub[27]); + ck_assert_msg( + last_msg.msg.itrf.stub[28] == 0, + "incorrect value for last_msg.msg.itrf.stub[28], expected 0, is %d", + last_msg.msg.itrf.stub[28]); + ck_assert_msg( + last_msg.msg.itrf.stub[29] == 0, + "incorrect value for last_msg.msg.itrf.stub[29], expected 0, is %d", + last_msg.msg.itrf.stub[29]); + ck_assert_msg( + last_msg.msg.itrf.stub[30] == 0, + "incorrect value for last_msg.msg.itrf.stub[30], expected 0, is %d", + last_msg.msg.itrf.stub[30]); + ck_assert_msg( + last_msg.msg.itrf.stub[31] == 0, + "incorrect value for last_msg.msg.itrf.stub[31], expected 0, is %d", + last_msg.msg.itrf.stub[31]); + ck_assert_msg( + last_msg.msg.itrf.stub[32] == 0, + "incorrect value for last_msg.msg.itrf.stub[32], expected 0, is %d", + last_msg.msg.itrf.stub[32]); + ck_assert_msg( + last_msg.msg.itrf.stub[33] == 3, + "incorrect value for last_msg.msg.itrf.stub[33], expected 3, is %d", + last_msg.msg.itrf.stub[33]); + ck_assert_msg( + last_msg.msg.itrf.stub[34] == 98, + "incorrect value for last_msg.msg.itrf.stub[34], expected 98, is %d", + last_msg.msg.itrf.stub[34]); + ck_assert_msg( + last_msg.msg.itrf.stub[35] == 97, + "incorrect value for last_msg.msg.itrf.stub[35], expected 97, is %d", + last_msg.msg.itrf.stub[35]); + ck_assert_msg( + last_msg.msg.itrf.stub[36] == 114, + "incorrect value for last_msg.msg.itrf.stub[36], expected 114, is %d", + last_msg.msg.itrf.stub[36]); + ck_assert_msg( + last_msg.msg.itrf.stub[37] == 0, + "incorrect value for last_msg.msg.itrf.stub[37], expected 0, is %d", + last_msg.msg.itrf.stub[37]); + ck_assert_msg( + last_msg.msg.itrf.stub[38] == 0, + "incorrect value for last_msg.msg.itrf.stub[38], expected 0, is %d", + last_msg.msg.itrf.stub[38]); + ck_assert_msg( + last_msg.msg.itrf.stub[39] == 0, + "incorrect value for last_msg.msg.itrf.stub[39], expected 0, is %d", + last_msg.msg.itrf.stub[39]); + ck_assert_msg( + last_msg.msg.itrf.stub[40] == 0, + "incorrect value for last_msg.msg.itrf.stub[40], expected 0, is %d", + last_msg.msg.itrf.stub[40]); + ck_assert_msg( + last_msg.msg.itrf.stub[41] == 0, + "incorrect value for last_msg.msg.itrf.stub[41], expected 0, is %d", + last_msg.msg.itrf.stub[41]); + ck_assert_msg( + last_msg.msg.itrf.stub[42] == 0, + "incorrect value for last_msg.msg.itrf.stub[42], expected 0, is %d", + last_msg.msg.itrf.stub[42]); + ck_assert_msg( + last_msg.msg.itrf.stub[43] == 0, + "incorrect value for last_msg.msg.itrf.stub[43], expected 0, is %d", + last_msg.msg.itrf.stub[43]); + ck_assert_msg( + last_msg.msg.itrf.stub[44] == 0, + "incorrect value for last_msg.msg.itrf.stub[44], expected 0, is %d", + last_msg.msg.itrf.stub[44]); + ck_assert_msg( + last_msg.msg.itrf.stub[45] == 0, + "incorrect value for last_msg.msg.itrf.stub[45], expected 0, is %d", + last_msg.msg.itrf.stub[45]); + ck_assert_msg( + last_msg.msg.itrf.stub[46] == 0, + "incorrect value for last_msg.msg.itrf.stub[46], expected 0, is %d", + last_msg.msg.itrf.stub[46]); + ck_assert_msg( + last_msg.msg.itrf.stub[47] == 0, + "incorrect value for last_msg.msg.itrf.stub[47], expected 0, is %d", + last_msg.msg.itrf.stub[47]); + ck_assert_msg( + last_msg.msg.itrf.stub[48] == 0, + "incorrect value for last_msg.msg.itrf.stub[48], expected 0, is %d", + last_msg.msg.itrf.stub[48]); + ck_assert_msg( + last_msg.msg.itrf.stub[49] == 0, + "incorrect value for last_msg.msg.itrf.stub[49], expected 0, is %d", + last_msg.msg.itrf.stub[49]); + ck_assert_msg( + last_msg.msg.itrf.stub[50] == 0, + "incorrect value for last_msg.msg.itrf.stub[50], expected 0, is %d", + last_msg.msg.itrf.stub[50]); + ck_assert_msg( + last_msg.msg.itrf.stub[51] == 0, + "incorrect value for last_msg.msg.itrf.stub[51], expected 0, is %d", + last_msg.msg.itrf.stub[51]); + ck_assert_msg( + last_msg.msg.itrf.stub[52] == 0, + "incorrect value for last_msg.msg.itrf.stub[52], expected 0, is %d", + last_msg.msg.itrf.stub[52]); + ck_assert_msg( + last_msg.msg.itrf.stub[53] == 0, + "incorrect value for last_msg.msg.itrf.stub[53], expected 0, is %d", + last_msg.msg.itrf.stub[53]); + ck_assert_msg( + last_msg.msg.itrf.stub[54] == 0, + "incorrect value for last_msg.msg.itrf.stub[54], expected 0, is %d", + last_msg.msg.itrf.stub[54]); + ck_assert_msg( + last_msg.msg.itrf.stub[55] == 0, + "incorrect value for last_msg.msg.itrf.stub[55], expected 0, is %d", + last_msg.msg.itrf.stub[55]); + ck_assert_msg( + last_msg.msg.itrf.stub[56] == 0, + "incorrect value for last_msg.msg.itrf.stub[56], expected 0, is %d", + last_msg.msg.itrf.stub[56]); + ck_assert_msg( + last_msg.msg.itrf.stub[57] == 0, + "incorrect value for last_msg.msg.itrf.stub[57], expected 0, is %d", + last_msg.msg.itrf.stub[57]); + ck_assert_msg( + last_msg.msg.itrf.stub[58] == 0, + "incorrect value for last_msg.msg.itrf.stub[58], expected 0, is %d", + last_msg.msg.itrf.stub[58]); + ck_assert_msg( + last_msg.msg.itrf.stub[59] == 0, + "incorrect value for last_msg.msg.itrf.stub[59], expected 0, is %d", + last_msg.msg.itrf.stub[59]); + ck_assert_msg( + last_msg.msg.itrf.stub[60] == 0, + "incorrect value for last_msg.msg.itrf.stub[60], expected 0, is %d", + last_msg.msg.itrf.stub[60]); + ck_assert_msg( + last_msg.msg.itrf.stub[61] == 0, + "incorrect value for last_msg.msg.itrf.stub[61], expected 0, is %d", + last_msg.msg.itrf.stub[61]); + ck_assert_msg( + last_msg.msg.itrf.stub[62] == 0, + "incorrect value for last_msg.msg.itrf.stub[62], expected 0, is %d", + last_msg.msg.itrf.stub[62]); + ck_assert_msg( + last_msg.msg.itrf.stub[63] == 0, + "incorrect value for last_msg.msg.itrf.stub[63], expected 0, is %d", + last_msg.msg.itrf.stub[63]); + ck_assert_msg( + last_msg.msg.itrf.stub[64] == 0, + "incorrect value for last_msg.msg.itrf.stub[64], expected 0, is %d", + last_msg.msg.itrf.stub[64]); + ck_assert_msg( + last_msg.msg.itrf.stub[65] == 4, + "incorrect value for last_msg.msg.itrf.stub[65], expected 4, is %d", + last_msg.msg.itrf.stub[65]); + ck_assert_msg( + last_msg.msg.itrf.stub[66] == 5, + "incorrect value for last_msg.msg.itrf.stub[66], expected 5, is %d", + last_msg.msg.itrf.stub[66]); + ck_assert_msg( + last_msg.msg.itrf.stub[67] == 0, + "incorrect value for last_msg.msg.itrf.stub[67], expected 0, is %d", + last_msg.msg.itrf.stub[67]); + ck_assert_msg( + last_msg.msg.itrf.stub[68] == 6, + "incorrect value for last_msg.msg.itrf.stub[68], expected 6, is %d", + last_msg.msg.itrf.stub[68]); + ck_assert_msg( + last_msg.msg.itrf.stub[69] == 0, + "incorrect value for last_msg.msg.itrf.stub[69], expected 0, is %d", + last_msg.msg.itrf.stub[69]); + ck_assert_msg( + last_msg.msg.itrf.stub[70] == 7, + "incorrect value for last_msg.msg.itrf.stub[70], expected 7, is %d", + last_msg.msg.itrf.stub[70]); + ck_assert_msg( + last_msg.msg.itrf.stub[71] == 0, + "incorrect value for last_msg.msg.itrf.stub[71], expected 0, is %d", + last_msg.msg.itrf.stub[71]); + ck_assert_msg( + last_msg.msg.itrf.stub[72] == 0, + "incorrect value for last_msg.msg.itrf.stub[72], expected 0, is %d", + last_msg.msg.itrf.stub[72]); + ck_assert_msg( + last_msg.msg.itrf.stub[73] == 0, + "incorrect value for last_msg.msg.itrf.stub[73], expected 0, is %d", + last_msg.msg.itrf.stub[73]); + ck_assert_msg( + last_msg.msg.itrf.stub[74] == 8, + "incorrect value for last_msg.msg.itrf.stub[74], expected 8, is %d", + last_msg.msg.itrf.stub[74]); + ck_assert_msg( + last_msg.msg.itrf.stub[75] == 0, + "incorrect value for last_msg.msg.itrf.stub[75], expected 0, is %d", + last_msg.msg.itrf.stub[75]); + ck_assert_msg( + last_msg.msg.itrf.stub[76] == 0, + "incorrect value for last_msg.msg.itrf.stub[76], expected 0, is %d", + last_msg.msg.itrf.stub[76]); + ck_assert_msg( + last_msg.msg.itrf.stub[77] == 0, + "incorrect value for last_msg.msg.itrf.stub[77], expected 0, is %d", + last_msg.msg.itrf.stub[77]); + ck_assert_msg( + last_msg.msg.itrf.stub[78] == 9, + "incorrect value for last_msg.msg.itrf.stub[78], expected 9, is %d", + last_msg.msg.itrf.stub[78]); + ck_assert_msg( + last_msg.msg.itrf.stub[79] == 0, + "incorrect value for last_msg.msg.itrf.stub[79], expected 0, is %d", + last_msg.msg.itrf.stub[79]); + ck_assert_msg( + last_msg.msg.itrf.stub[80] == 0, + "incorrect value for last_msg.msg.itrf.stub[80], expected 0, is %d", + last_msg.msg.itrf.stub[80]); + ck_assert_msg( + last_msg.msg.itrf.stub[81] == 0, + "incorrect value for last_msg.msg.itrf.stub[81], expected 0, is %d", + last_msg.msg.itrf.stub[81]); + ck_assert_msg( + last_msg.msg.itrf.stub[82] == 10, + "incorrect value for last_msg.msg.itrf.stub[82], expected 10, is %d", + last_msg.msg.itrf.stub[82]); + ck_assert_msg( + last_msg.msg.itrf.stub[83] == 0, + "incorrect value for last_msg.msg.itrf.stub[83], expected 0, is %d", + last_msg.msg.itrf.stub[83]); + ck_assert_msg( + last_msg.msg.itrf.stub[84] == 0, + "incorrect value for last_msg.msg.itrf.stub[84], expected 0, is %d", + last_msg.msg.itrf.stub[84]); + ck_assert_msg( + last_msg.msg.itrf.stub[85] == 0, + "incorrect value for last_msg.msg.itrf.stub[85], expected 0, is %d", + last_msg.msg.itrf.stub[85]); + ck_assert_msg( + last_msg.msg.itrf.stub[86] == 11, + "incorrect value for last_msg.msg.itrf.stub[86], expected 11, is %d", + last_msg.msg.itrf.stub[86]); + ck_assert_msg( + last_msg.msg.itrf.stub[87] == 0, + "incorrect value for last_msg.msg.itrf.stub[87], expected 0, is %d", + last_msg.msg.itrf.stub[87]); + ck_assert_msg( + last_msg.msg.itrf.stub[88] == 0, + "incorrect value for last_msg.msg.itrf.stub[88], expected 0, is %d", + last_msg.msg.itrf.stub[88]); + ck_assert_msg( + last_msg.msg.itrf.stub[89] == 0, + "incorrect value for last_msg.msg.itrf.stub[89], expected 0, is %d", + last_msg.msg.itrf.stub[89]); + ck_assert_msg( + last_msg.msg.itrf.stub[90] == 12, + "incorrect value for last_msg.msg.itrf.stub[90], expected 12, is %d", + last_msg.msg.itrf.stub[90]); + ck_assert_msg( + last_msg.msg.itrf.stub[91] == 0, + "incorrect value for last_msg.msg.itrf.stub[91], expected 0, is %d", + last_msg.msg.itrf.stub[91]); + ck_assert_msg( + last_msg.msg.itrf.stub[92] == 0, + "incorrect value for last_msg.msg.itrf.stub[92], expected 0, is %d", + last_msg.msg.itrf.stub[92]); + ck_assert_msg( + last_msg.msg.itrf.stub[93] == 0, + "incorrect value for last_msg.msg.itrf.stub[93], expected 0, is %d", + last_msg.msg.itrf.stub[93]); + ck_assert_msg( + last_msg.msg.itrf.stub[94] == 13, + "incorrect value for last_msg.msg.itrf.stub[94], expected 13, is %d", + last_msg.msg.itrf.stub[94]); + ck_assert_msg( + last_msg.msg.itrf.stub[95] == 0, + "incorrect value for last_msg.msg.itrf.stub[95], expected 0, is %d", + last_msg.msg.itrf.stub[95]); + ck_assert_msg( + last_msg.msg.itrf.stub[96] == 0, + "incorrect value for last_msg.msg.itrf.stub[96], expected 0, is %d", + last_msg.msg.itrf.stub[96]); + ck_assert_msg( + last_msg.msg.itrf.stub[97] == 0, + "incorrect value for last_msg.msg.itrf.stub[97], expected 0, is %d", + last_msg.msg.itrf.stub[97]); + ck_assert_msg( + last_msg.msg.itrf.stub[98] == 14, + "incorrect value for last_msg.msg.itrf.stub[98], expected 14, is %d", + last_msg.msg.itrf.stub[98]); + ck_assert_msg( + last_msg.msg.itrf.stub[99] == 0, + "incorrect value for last_msg.msg.itrf.stub[99], expected 0, is %d", + last_msg.msg.itrf.stub[99]); + ck_assert_msg( + last_msg.msg.itrf.stub[100] == 0, + "incorrect value for last_msg.msg.itrf.stub[100], expected 0, is %d", + last_msg.msg.itrf.stub[100]); + ck_assert_msg( + last_msg.msg.itrf.stub[101] == 0, + "incorrect value for last_msg.msg.itrf.stub[101], expected 0, is %d", + last_msg.msg.itrf.stub[101]); + ck_assert_msg( + last_msg.msg.itrf.stub[102] == 15, + "incorrect value for last_msg.msg.itrf.stub[102], expected 15, is %d", + last_msg.msg.itrf.stub[102]); + ck_assert_msg( + last_msg.msg.itrf.stub[103] == 0, + "incorrect value for last_msg.msg.itrf.stub[103], expected 0, is %d", + last_msg.msg.itrf.stub[103]); + ck_assert_msg( + last_msg.msg.itrf.stub[104] == 0, + "incorrect value for last_msg.msg.itrf.stub[104], expected 0, is %d", + last_msg.msg.itrf.stub[104]); + ck_assert_msg( + last_msg.msg.itrf.stub[105] == 0, + "incorrect value for last_msg.msg.itrf.stub[105], expected 0, is %d", + last_msg.msg.itrf.stub[105]); + ck_assert_msg( + last_msg.msg.itrf.stub[106] == 16, + "incorrect value for last_msg.msg.itrf.stub[106], expected 16, is %d", + last_msg.msg.itrf.stub[106]); + ck_assert_msg( + last_msg.msg.itrf.stub[107] == 0, + "incorrect value for last_msg.msg.itrf.stub[107], expected 0, is %d", + last_msg.msg.itrf.stub[107]); + ck_assert_msg( + last_msg.msg.itrf.stub[108] == 0, + "incorrect value for last_msg.msg.itrf.stub[108], expected 0, is %d", + last_msg.msg.itrf.stub[108]); + ck_assert_msg( + last_msg.msg.itrf.stub[109] == 0, + "incorrect value for last_msg.msg.itrf.stub[109], expected 0, is %d", + last_msg.msg.itrf.stub[109]); + ck_assert_msg( + last_msg.msg.itrf.stub[110] == 17, + "incorrect value for last_msg.msg.itrf.stub[110], expected 17, is %d", + last_msg.msg.itrf.stub[110]); + ck_assert_msg( + last_msg.msg.itrf.stub[111] == 0, + "incorrect value for last_msg.msg.itrf.stub[111], expected 0, is %d", + last_msg.msg.itrf.stub[111]); + ck_assert_msg( + last_msg.msg.itrf.stub[112] == 0, + "incorrect value for last_msg.msg.itrf.stub[112], expected 0, is %d", + last_msg.msg.itrf.stub[112]); + ck_assert_msg( + last_msg.msg.itrf.stub[113] == 0, + "incorrect value for last_msg.msg.itrf.stub[113], expected 0, is %d", + last_msg.msg.itrf.stub[113]); + ck_assert_msg( + last_msg.msg.itrf.stub[114] == 18, + "incorrect value for last_msg.msg.itrf.stub[114], expected 18, is %d", + last_msg.msg.itrf.stub[114]); + ck_assert_msg( + last_msg.msg.itrf.stub[115] == 0, + "incorrect value for last_msg.msg.itrf.stub[115], expected 0, is %d", + last_msg.msg.itrf.stub[115]); + ck_assert_msg( + last_msg.msg.itrf.stub[116] == 0, + "incorrect value for last_msg.msg.itrf.stub[116], expected 0, is %d", + last_msg.msg.itrf.stub[116]); + ck_assert_msg( + last_msg.msg.itrf.stub[117] == 0, + "incorrect value for last_msg.msg.itrf.stub[117], expected 0, is %d", + last_msg.msg.itrf.stub[117]); + ck_assert_msg( + last_msg.msg.itrf.stub[118] == 19, + "incorrect value for last_msg.msg.itrf.stub[118], expected 19, is %d", + last_msg.msg.itrf.stub[118]); + ck_assert_msg( + last_msg.msg.itrf.stub[119] == 0, + "incorrect value for last_msg.msg.itrf.stub[119], expected 0, is %d", + last_msg.msg.itrf.stub[119]); + ck_assert_msg( + last_msg.msg.itrf.stub[120] == 0, + "incorrect value for last_msg.msg.itrf.stub[120], expected 0, is %d", + last_msg.msg.itrf.stub[120]); + ck_assert_msg( + last_msg.msg.itrf.stub[121] == 0, + "incorrect value for last_msg.msg.itrf.stub[121], expected 0, is %d", + last_msg.msg.itrf.stub[121]); + ck_assert_msg( + last_msg.msg.itrf.stub[122] == 20, + "incorrect value for last_msg.msg.itrf.stub[122], expected 20, is %d", + last_msg.msg.itrf.stub[122]); + ck_assert_msg( + last_msg.msg.itrf.stub[123] == 0, + "incorrect value for last_msg.msg.itrf.stub[123], expected 0, is %d", + last_msg.msg.itrf.stub[123]); + } +} +END_TEST + +Suite *auto_check_sbp_navigation_MsgItrf_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: auto_check_sbp_navigation_MsgItrf"); + TCase *tc_acq = + tcase_create("Automated_Suite_auto_check_sbp_navigation_MsgItrf"); + tcase_add_test(tc_acq, test_auto_check_sbp_navigation_MsgItrf); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds.c b/c/test/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds.c new file mode 100644 index 0000000000..a358a9cf02 --- /dev/null +++ b/c/test/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds.c @@ -0,0 +1,369 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrCodePhaseBiasesBounds.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + sbp_msg_type_t msg_type; + sbp_msg_t msg; + void *context; +} last_msg; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static void *DUMMY_MEMORY_FOR_CALLBACKS = (void *)0xdeadbeef; +static void *DUMMY_MEMORY_FOR_IO = (void *)0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return (s32)real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return (s32)real_n; +} + +static void logging_reset() { memset(&last_msg, 0, sizeof(last_msg)); } + +static void msg_callback(u16 sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.msg_type = msg_type; + last_msg.msg = *msg; + last_msg.context = context; +} + +START_TEST(test_auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds) { + static sbp_msg_callbacks_node_t n; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_callback_register(&sbp_state, 1516, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 236, 5, 66, 0, 31, 180, 0, 0, 0, 3, 0, 1, + 2, 1, 14, 15, 1, 3, 0, 3, 39, 1, 39, 1, 1, + 3, 39, 1, 39, 1, 1, 1, 39, 1, 39, 1, 23, 113, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.ssr_code_phase_biases_bounds.n_stub = 31; + + test_msg.ssr_code_phase_biases_bounds.stub[0] = 180; + + test_msg.ssr_code_phase_biases_bounds.stub[1] = 0; + + test_msg.ssr_code_phase_biases_bounds.stub[2] = 0; + + test_msg.ssr_code_phase_biases_bounds.stub[3] = 0; + + test_msg.ssr_code_phase_biases_bounds.stub[4] = 3; + + test_msg.ssr_code_phase_biases_bounds.stub[5] = 0; + + test_msg.ssr_code_phase_biases_bounds.stub[6] = 1; + + test_msg.ssr_code_phase_biases_bounds.stub[7] = 2; + + test_msg.ssr_code_phase_biases_bounds.stub[8] = 1; + + test_msg.ssr_code_phase_biases_bounds.stub[9] = 14; + + test_msg.ssr_code_phase_biases_bounds.stub[10] = 15; + + test_msg.ssr_code_phase_biases_bounds.stub[11] = 1; + + test_msg.ssr_code_phase_biases_bounds.stub[12] = 3; + + test_msg.ssr_code_phase_biases_bounds.stub[13] = 0; + + test_msg.ssr_code_phase_biases_bounds.stub[14] = 3; + + test_msg.ssr_code_phase_biases_bounds.stub[15] = 39; + + test_msg.ssr_code_phase_biases_bounds.stub[16] = 1; + + test_msg.ssr_code_phase_biases_bounds.stub[17] = 39; + + test_msg.ssr_code_phase_biases_bounds.stub[18] = 1; + + test_msg.ssr_code_phase_biases_bounds.stub[19] = 1; + + test_msg.ssr_code_phase_biases_bounds.stub[20] = 3; + + test_msg.ssr_code_phase_biases_bounds.stub[21] = 39; + + test_msg.ssr_code_phase_biases_bounds.stub[22] = 1; + + test_msg.ssr_code_phase_biases_bounds.stub[23] = 39; + + test_msg.ssr_code_phase_biases_bounds.stub[24] = 1; + + test_msg.ssr_code_phase_biases_bounds.stub[25] = 1; + + test_msg.ssr_code_phase_biases_bounds.stub[26] = 1; + + test_msg.ssr_code_phase_biases_bounds.stub[27] = 39; + + test_msg.ssr_code_phase_biases_bounds.stub[28] = 1; + + test_msg.ssr_code_phase_biases_bounds.stub[29] = 39; + + test_msg.ssr_code_phase_biases_bounds.stub[30] = 1; + + sbp_message_send(&sbp_state, SbpMsgSsrCodePhaseBiasesBounds, 66, &test_msg, + &dummy_write); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff (expected: %zu, " + "actual: %zu)", + sizeof(encoded_frame), dummy_wr); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + + ck_assert_msg(sbp_message_cmp(SbpMsgSsrCodePhaseBiasesBounds, &last_msg.msg, + &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.n_stub == 31, + "incorrect value for last_msg.msg.ssr_code_phase_biases_bounds.n_stub, " + "expected 31, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.n_stub); + + ck_assert_msg(last_msg.msg.ssr_code_phase_biases_bounds.stub[0] == 180, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[0], expected " + "180, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[0]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[1] == 0, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[1], expected 0, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[1]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[2] == 0, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[2], expected 0, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[2]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[3] == 0, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[3], expected 0, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[3]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[4] == 3, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[4], expected 3, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[4]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[5] == 0, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[5], expected 0, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[5]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[6] == 1, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[6], expected 1, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[6]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[7] == 2, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[7], expected 2, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[7]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[8] == 1, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[8], expected 1, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[8]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[9] == 14, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[9], expected 14, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[9]); + ck_assert_msg(last_msg.msg.ssr_code_phase_biases_bounds.stub[10] == 15, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[10], " + "expected 15, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[10]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[11] == 1, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[11], expected 1, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[11]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[12] == 3, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[12], expected 3, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[12]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[13] == 0, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[13], expected 0, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[13]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[14] == 3, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[14], expected 3, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[14]); + ck_assert_msg(last_msg.msg.ssr_code_phase_biases_bounds.stub[15] == 39, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[15], " + "expected 39, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[15]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[16] == 1, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[16], expected 1, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[16]); + ck_assert_msg(last_msg.msg.ssr_code_phase_biases_bounds.stub[17] == 39, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[17], " + "expected 39, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[17]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[18] == 1, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[18], expected 1, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[18]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[19] == 1, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[19], expected 1, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[19]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[20] == 3, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[20], expected 3, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[20]); + ck_assert_msg(last_msg.msg.ssr_code_phase_biases_bounds.stub[21] == 39, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[21], " + "expected 39, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[21]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[22] == 1, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[22], expected 1, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[22]); + ck_assert_msg(last_msg.msg.ssr_code_phase_biases_bounds.stub[23] == 39, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[23], " + "expected 39, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[23]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[24] == 1, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[24], expected 1, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[24]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[25] == 1, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[25], expected 1, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[25]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[26] == 1, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[26], expected 1, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[26]); + ck_assert_msg(last_msg.msg.ssr_code_phase_biases_bounds.stub[27] == 39, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[27], " + "expected 39, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[27]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[28] == 1, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[28], expected 1, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[28]); + ck_assert_msg(last_msg.msg.ssr_code_phase_biases_bounds.stub[29] == 39, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[29], " + "expected 39, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[29]); + ck_assert_msg( + last_msg.msg.ssr_code_phase_biases_bounds.stub[30] == 1, + "incorrect value for " + "last_msg.msg.ssr_code_phase_biases_bounds.stub[30], expected 1, is %d", + last_msg.msg.ssr_code_phase_biases_bounds.stub[30]); + } +} +END_TEST + +Suite *auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds"); + TCase *tc_acq = tcase_create( + "Automated_Suite_auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds"); + tcase_add_test(tc_acq, test_auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds.c b/c/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds.c new file mode 100644 index 0000000000..9138c6473f --- /dev/null +++ b/c/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds.c @@ -0,0 +1,454 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrectionBounds.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + sbp_msg_type_t msg_type; + sbp_msg_t msg; + void *context; +} last_msg; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static void *DUMMY_MEMORY_FOR_CALLBACKS = (void *)0xdeadbeef; +static void *DUMMY_MEMORY_FOR_IO = (void *)0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return (s32)real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return (s32)real_n; +} + +static void logging_reset() { memset(&last_msg, 0, sizeof(last_msg)); } + +static void msg_callback(u16 sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.msg_type = msg_type; + last_msg.msg = *msg; + last_msg.context = context; +} + +START_TEST(test_auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds) { + static sbp_msg_callbacks_node_t n; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_callback_register(&sbp_state, 1534, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 254, 5, 66, 0, 43, 180, 0, 0, 0, 3, 0, 1, + 1, 10, 0, 15, 1, 0, 10, 0, 39, 232, 3, 244, 1, + 100, 200, 150, 100, 2, 5, 10, 16, 0, 17, 18, 19, 20, + 21, 6, 10, 22, 0, 23, 24, 25, 26, 27, 112, 145, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.ssr_gridded_correction_bounds.n_stub = 43; + + test_msg.ssr_gridded_correction_bounds.stub[0] = 180; + + test_msg.ssr_gridded_correction_bounds.stub[1] = 0; + + test_msg.ssr_gridded_correction_bounds.stub[2] = 0; + + test_msg.ssr_gridded_correction_bounds.stub[3] = 0; + + test_msg.ssr_gridded_correction_bounds.stub[4] = 3; + + test_msg.ssr_gridded_correction_bounds.stub[5] = 0; + + test_msg.ssr_gridded_correction_bounds.stub[6] = 1; + + test_msg.ssr_gridded_correction_bounds.stub[7] = 1; + + test_msg.ssr_gridded_correction_bounds.stub[8] = 10; + + test_msg.ssr_gridded_correction_bounds.stub[9] = 0; + + test_msg.ssr_gridded_correction_bounds.stub[10] = 15; + + test_msg.ssr_gridded_correction_bounds.stub[11] = 1; + + test_msg.ssr_gridded_correction_bounds.stub[12] = 0; + + test_msg.ssr_gridded_correction_bounds.stub[13] = 10; + + test_msg.ssr_gridded_correction_bounds.stub[14] = 0; + + test_msg.ssr_gridded_correction_bounds.stub[15] = 39; + + test_msg.ssr_gridded_correction_bounds.stub[16] = 232; + + test_msg.ssr_gridded_correction_bounds.stub[17] = 3; + + test_msg.ssr_gridded_correction_bounds.stub[18] = 244; + + test_msg.ssr_gridded_correction_bounds.stub[19] = 1; + + test_msg.ssr_gridded_correction_bounds.stub[20] = 100; + + test_msg.ssr_gridded_correction_bounds.stub[21] = 200; + + test_msg.ssr_gridded_correction_bounds.stub[22] = 150; + + test_msg.ssr_gridded_correction_bounds.stub[23] = 100; + + test_msg.ssr_gridded_correction_bounds.stub[24] = 2; + + test_msg.ssr_gridded_correction_bounds.stub[25] = 5; + + test_msg.ssr_gridded_correction_bounds.stub[26] = 10; + + test_msg.ssr_gridded_correction_bounds.stub[27] = 16; + + test_msg.ssr_gridded_correction_bounds.stub[28] = 0; + + test_msg.ssr_gridded_correction_bounds.stub[29] = 17; + + test_msg.ssr_gridded_correction_bounds.stub[30] = 18; + + test_msg.ssr_gridded_correction_bounds.stub[31] = 19; + + test_msg.ssr_gridded_correction_bounds.stub[32] = 20; + + test_msg.ssr_gridded_correction_bounds.stub[33] = 21; + + test_msg.ssr_gridded_correction_bounds.stub[34] = 6; + + test_msg.ssr_gridded_correction_bounds.stub[35] = 10; + + test_msg.ssr_gridded_correction_bounds.stub[36] = 22; + + test_msg.ssr_gridded_correction_bounds.stub[37] = 0; + + test_msg.ssr_gridded_correction_bounds.stub[38] = 23; + + test_msg.ssr_gridded_correction_bounds.stub[39] = 24; + + test_msg.ssr_gridded_correction_bounds.stub[40] = 25; + + test_msg.ssr_gridded_correction_bounds.stub[41] = 26; + + test_msg.ssr_gridded_correction_bounds.stub[42] = 27; + + sbp_message_send(&sbp_state, SbpMsgSsrGriddedCorrectionBounds, 66, + &test_msg, &dummy_write); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff (expected: %zu, " + "actual: %zu)", + sizeof(encoded_frame), dummy_wr); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + + ck_assert_msg(sbp_message_cmp(SbpMsgSsrGriddedCorrectionBounds, + &last_msg.msg, &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg( + last_msg.msg.ssr_gridded_correction_bounds.n_stub == 43, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.n_stub, expected 43, is %d", + last_msg.msg.ssr_gridded_correction_bounds.n_stub); + + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[0] == 180, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[0], " + "expected 180, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[0]); + ck_assert_msg( + last_msg.msg.ssr_gridded_correction_bounds.stub[1] == 0, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[1], expected 0, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[1]); + ck_assert_msg( + last_msg.msg.ssr_gridded_correction_bounds.stub[2] == 0, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[2], expected 0, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[2]); + ck_assert_msg( + last_msg.msg.ssr_gridded_correction_bounds.stub[3] == 0, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[3], expected 0, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[3]); + ck_assert_msg( + last_msg.msg.ssr_gridded_correction_bounds.stub[4] == 3, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[4], expected 3, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[4]); + ck_assert_msg( + last_msg.msg.ssr_gridded_correction_bounds.stub[5] == 0, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[5], expected 0, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[5]); + ck_assert_msg( + last_msg.msg.ssr_gridded_correction_bounds.stub[6] == 1, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[6], expected 1, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[6]); + ck_assert_msg( + last_msg.msg.ssr_gridded_correction_bounds.stub[7] == 1, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[7], expected 1, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[7]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[8] == 10, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[8], " + "expected 10, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[8]); + ck_assert_msg( + last_msg.msg.ssr_gridded_correction_bounds.stub[9] == 0, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[9], expected 0, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[9]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[10] == 15, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[10], " + "expected 15, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[10]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[11] == 1, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[11], " + "expected 1, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[11]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[12] == 0, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[12], " + "expected 0, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[12]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[13] == 10, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[13], " + "expected 10, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[13]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[14] == 0, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[14], " + "expected 0, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[14]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[15] == 39, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[15], " + "expected 39, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[15]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[16] == 232, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[16], " + "expected 232, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[16]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[17] == 3, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[17], " + "expected 3, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[17]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[18] == 244, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[18], " + "expected 244, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[18]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[19] == 1, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[19], " + "expected 1, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[19]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[20] == 100, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[20], " + "expected 100, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[20]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[21] == 200, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[21], " + "expected 200, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[21]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[22] == 150, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[22], " + "expected 150, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[22]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[23] == 100, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[23], " + "expected 100, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[23]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[24] == 2, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[24], " + "expected 2, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[24]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[25] == 5, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[25], " + "expected 5, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[25]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[26] == 10, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[26], " + "expected 10, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[26]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[27] == 16, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[27], " + "expected 16, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[27]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[28] == 0, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[28], " + "expected 0, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[28]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[29] == 17, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[29], " + "expected 17, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[29]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[30] == 18, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[30], " + "expected 18, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[30]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[31] == 19, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[31], " + "expected 19, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[31]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[32] == 20, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[32], " + "expected 20, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[32]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[33] == 21, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[33], " + "expected 21, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[33]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[34] == 6, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[34], " + "expected 6, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[34]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[35] == 10, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[35], " + "expected 10, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[35]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[36] == 22, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[36], " + "expected 22, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[36]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[37] == 0, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[37], " + "expected 0, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[37]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[38] == 23, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[38], " + "expected 23, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[38]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[39] == 24, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[39], " + "expected 24, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[39]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[40] == 25, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[40], " + "expected 25, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[40]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[41] == 26, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[41], " + "expected 26, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[41]); + ck_assert_msg(last_msg.msg.ssr_gridded_correction_bounds.stub[42] == 27, + "incorrect value for " + "last_msg.msg.ssr_gridded_correction_bounds.stub[42], " + "expected 27, is %d", + last_msg.msg.ssr_gridded_correction_bounds.stub[42]); + } +} +END_TEST + +Suite *auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds"); + TCase *tc_acq = tcase_create( + "Automated_Suite_auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds"); + tcase_add_test(tc_acq, test_auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/auto_check_sbp_ssr_MsgSsrOrbitClockBounds.c b/c/test/auto_check_sbp_ssr_MsgSsrOrbitClockBounds.c new file mode 100644 index 0000000000..6e0484c228 --- /dev/null +++ b/c/test/auto_check_sbp_ssr_MsgSsrOrbitClockBounds.c @@ -0,0 +1,368 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBounds.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + sbp_msg_type_t msg_type; + sbp_msg_t msg; + void *context; +} last_msg; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static void *DUMMY_MEMORY_FOR_CALLBACKS = (void *)0xdeadbeef; +static void *DUMMY_MEMORY_FOR_IO = (void *)0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return (s32)real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return (s32)real_n; +} + +static void logging_reset() { memset(&last_msg, 0, sizeof(last_msg)); } + +static void msg_callback(u16 sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.msg_type = msg_type; + last_msg.msg = *msg; + last_msg.context = context; +} + +START_TEST(test_auto_check_sbp_ssr_MsgSsrOrbitClockBounds) { + static sbp_msg_callbacks_node_t n; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_callback_register(&sbp_state, 1502, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 222, 5, 66, 0, 31, 180, 0, 0, 0, 3, 0, 1, + 2, 3, 48, 15, 1, 2, 24, 39, 38, 37, 1, 2, 3, + 39, 1, 3, 39, 38, 37, 1, 2, 3, 39, 1, 21, 85, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.ssr_orbit_clock_bounds.n_stub = 31; + + test_msg.ssr_orbit_clock_bounds.stub[0] = 180; + + test_msg.ssr_orbit_clock_bounds.stub[1] = 0; + + test_msg.ssr_orbit_clock_bounds.stub[2] = 0; + + test_msg.ssr_orbit_clock_bounds.stub[3] = 0; + + test_msg.ssr_orbit_clock_bounds.stub[4] = 3; + + test_msg.ssr_orbit_clock_bounds.stub[5] = 0; + + test_msg.ssr_orbit_clock_bounds.stub[6] = 1; + + test_msg.ssr_orbit_clock_bounds.stub[7] = 2; + + test_msg.ssr_orbit_clock_bounds.stub[8] = 3; + + test_msg.ssr_orbit_clock_bounds.stub[9] = 48; + + test_msg.ssr_orbit_clock_bounds.stub[10] = 15; + + test_msg.ssr_orbit_clock_bounds.stub[11] = 1; + + test_msg.ssr_orbit_clock_bounds.stub[12] = 2; + + test_msg.ssr_orbit_clock_bounds.stub[13] = 24; + + test_msg.ssr_orbit_clock_bounds.stub[14] = 39; + + test_msg.ssr_orbit_clock_bounds.stub[15] = 38; + + test_msg.ssr_orbit_clock_bounds.stub[16] = 37; + + test_msg.ssr_orbit_clock_bounds.stub[17] = 1; + + test_msg.ssr_orbit_clock_bounds.stub[18] = 2; + + test_msg.ssr_orbit_clock_bounds.stub[19] = 3; + + test_msg.ssr_orbit_clock_bounds.stub[20] = 39; + + test_msg.ssr_orbit_clock_bounds.stub[21] = 1; + + test_msg.ssr_orbit_clock_bounds.stub[22] = 3; + + test_msg.ssr_orbit_clock_bounds.stub[23] = 39; + + test_msg.ssr_orbit_clock_bounds.stub[24] = 38; + + test_msg.ssr_orbit_clock_bounds.stub[25] = 37; + + test_msg.ssr_orbit_clock_bounds.stub[26] = 1; + + test_msg.ssr_orbit_clock_bounds.stub[27] = 2; + + test_msg.ssr_orbit_clock_bounds.stub[28] = 3; + + test_msg.ssr_orbit_clock_bounds.stub[29] = 39; + + test_msg.ssr_orbit_clock_bounds.stub[30] = 1; + + sbp_message_send(&sbp_state, SbpMsgSsrOrbitClockBounds, 66, &test_msg, + &dummy_write); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff (expected: %zu, " + "actual: %zu)", + sizeof(encoded_frame), dummy_wr); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + + ck_assert_msg(sbp_message_cmp(SbpMsgSsrOrbitClockBounds, &last_msg.msg, + &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.n_stub == 31, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.n_stub, " + "expected 31, is %d", + last_msg.msg.ssr_orbit_clock_bounds.n_stub); + + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[0] == 180, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[0], " + "expected 180, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[0]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[1] == 0, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[1], " + "expected 0, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[1]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[2] == 0, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[2], " + "expected 0, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[2]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[3] == 0, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[3], " + "expected 0, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[3]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[4] == 3, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[4], " + "expected 3, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[4]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[5] == 0, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[5], " + "expected 0, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[5]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[6] == 1, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[6], " + "expected 1, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[6]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[7] == 2, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[7], " + "expected 2, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[7]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[8] == 3, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[8], " + "expected 3, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[8]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[9] == 48, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[9], " + "expected 48, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[9]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[10] == 15, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[10], " + "expected 15, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[10]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[11] == 1, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[11], " + "expected 1, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[11]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[12] == 2, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[12], " + "expected 2, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[12]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[13] == 24, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[13], " + "expected 24, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[13]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[14] == 39, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[14], " + "expected 39, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[14]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[15] == 38, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[15], " + "expected 38, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[15]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[16] == 37, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[16], " + "expected 37, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[16]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[17] == 1, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[17], " + "expected 1, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[17]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[18] == 2, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[18], " + "expected 2, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[18]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[19] == 3, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[19], " + "expected 3, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[19]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[20] == 39, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[20], " + "expected 39, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[20]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[21] == 1, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[21], " + "expected 1, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[21]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[22] == 3, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[22], " + "expected 3, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[22]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[23] == 39, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[23], " + "expected 39, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[23]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[24] == 38, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[24], " + "expected 38, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[24]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[25] == 37, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[25], " + "expected 37, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[25]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[26] == 1, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[26], " + "expected 1, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[26]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[27] == 2, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[27], " + "expected 2, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[27]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[28] == 3, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[28], " + "expected 3, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[28]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[29] == 39, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[29], " + "expected 39, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[29]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds.stub[30] == 1, + "incorrect value for last_msg.msg.ssr_orbit_clock_bounds.stub[30], " + "expected 1, is %d", + last_msg.msg.ssr_orbit_clock_bounds.stub[30]); + } +} +END_TEST + +Suite *auto_check_sbp_ssr_MsgSsrOrbitClockBounds_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: auto_check_sbp_ssr_MsgSsrOrbitClockBounds"); + TCase *tc_acq = + tcase_create("Automated_Suite_auto_check_sbp_ssr_MsgSsrOrbitClockBounds"); + tcase_add_test(tc_acq, test_auto_check_sbp_ssr_MsgSsrOrbitClockBounds); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation.c b/c/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation.c new file mode 100644 index 0000000000..44fa3140e3 --- /dev/null +++ b/c/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation.c @@ -0,0 +1,360 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBoundsDegradation.yaml +// by generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + sbp_msg_type_t msg_type; + sbp_msg_t msg; + void *context; +} last_msg; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static void *DUMMY_MEMORY_FOR_CALLBACKS = (void *)0xdeadbeef; +static void *DUMMY_MEMORY_FOR_IO = (void *)0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return (s32)real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return (s32)real_n; +} + +static void logging_reset() { memset(&last_msg, 0, sizeof(last_msg)); } + +static void msg_callback(u16 sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.msg_type = msg_type; + last_msg.msg = *msg; + last_msg.context = context; +} + +START_TEST(test_auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation) { + static sbp_msg_callbacks_node_t n; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_callback_register(&sbp_state, 1503, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 223, 5, 66, 0, 28, 180, 0, 0, 0, 3, 0, + 1, 2, 3, 48, 15, 1, 10, 0, 0, 0, 0, 0, + 0, 0, 200, 199, 198, 197, 196, 195, 194, 193, 200, 117, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.ssr_orbit_clock_bounds_degradation.n_stub = 28; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[0] = 180; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[1] = 0; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[2] = 0; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[3] = 0; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[4] = 3; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[5] = 0; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[6] = 1; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[7] = 2; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[8] = 3; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[9] = 48; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[10] = 15; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[11] = 1; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[12] = 10; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[13] = 0; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[14] = 0; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[15] = 0; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[16] = 0; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[17] = 0; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[18] = 0; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[19] = 0; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[20] = 200; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[21] = 199; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[22] = 198; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[23] = 197; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[24] = 196; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[25] = 195; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[26] = 194; + + test_msg.ssr_orbit_clock_bounds_degradation.stub[27] = 193; + + sbp_message_send(&sbp_state, SbpMsgSsrOrbitClockBoundsDegradation, 66, + &test_msg, &dummy_write); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff (expected: %zu, " + "actual: %zu)", + sizeof(encoded_frame), dummy_wr); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + + ck_assert_msg(sbp_message_cmp(SbpMsgSsrOrbitClockBoundsDegradation, + &last_msg.msg, &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.n_stub == 28, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.n_stub, " + "expected 28, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.n_stub); + + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[0] == 180, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[0], expected " + "180, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[0]); + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[1] == 0, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[1], " + "expected 0, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[1]); + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[2] == 0, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[2], " + "expected 0, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[2]); + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[3] == 0, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[3], " + "expected 0, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[3]); + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[4] == 3, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[4], " + "expected 3, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[4]); + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[5] == 0, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[5], " + "expected 0, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[5]); + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[6] == 1, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[6], " + "expected 1, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[6]); + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[7] == 2, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[7], " + "expected 2, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[7]); + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[8] == 3, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[8], " + "expected 3, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[8]); + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[9] == 48, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[9], " + "expected 48, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[9]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[10] == 15, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[10], expected " + "15, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[10]); + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[11] == 1, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[11], " + "expected 1, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[11]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[12] == 10, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[12], expected " + "10, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[12]); + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[13] == 0, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[13], " + "expected 0, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[13]); + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[14] == 0, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[14], " + "expected 0, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[14]); + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[15] == 0, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[15], " + "expected 0, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[15]); + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[16] == 0, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[16], " + "expected 0, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[16]); + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[17] == 0, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[17], " + "expected 0, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[17]); + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[18] == 0, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[18], " + "expected 0, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[18]); + ck_assert_msg(last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[19] == 0, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[19], " + "expected 0, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[19]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[20] == 200, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[20], expected " + "200, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[20]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[21] == 199, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[21], expected " + "199, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[21]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[22] == 198, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[22], expected " + "198, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[22]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[23] == 197, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[23], expected " + "197, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[23]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[24] == 196, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[24], expected " + "196, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[24]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[25] == 195, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[25], expected " + "195, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[25]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[26] == 194, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[26], expected " + "194, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[26]); + ck_assert_msg( + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[27] == 193, + "incorrect value for " + "last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[27], expected " + "193, is %d", + last_msg.msg.ssr_orbit_clock_bounds_degradation.stub[27]); + } +} +END_TEST + +Suite *auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation"); + TCase *tc_acq = tcase_create( + "Automated_Suite_auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation"); + tcase_add_test(tc_acq, + test_auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/auto_check_sbp_ssr_MsgSsrStecCorrection.c b/c/test/auto_check_sbp_ssr_MsgSsrStecCorrection.c new file mode 100644 index 0000000000..46192a65e2 --- /dev/null +++ b/c/test/auto_check_sbp_ssr_MsgSsrStecCorrection.c @@ -0,0 +1,408 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrStecCorrection.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + sbp_msg_type_t msg_type; + sbp_msg_t msg; + void *context; +} last_msg; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static void *DUMMY_MEMORY_FOR_CALLBACKS = (void *)0xdeadbeef; +static void *DUMMY_MEMORY_FOR_IO = (void *)0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return (s32)real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return (s32)real_n; +} + +static void logging_reset() { memset(&last_msg, 0, sizeof(last_msg)); } + +static void msg_callback(u16 sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.msg_type = msg_type; + last_msg.msg = *msg; + last_msg.context = context; +} + +START_TEST(test_auto_check_sbp_ssr_MsgSsrStecCorrection) { + static sbp_msg_callbacks_node_t n; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_callback_register(&sbp_state, 1533, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 253, 5, 66, 0, 38, 180, 0, 0, 0, 3, 0, 1, 1, 10, 0, + 15, 1, 0, 10, 0, 2, 1, 1, 1, 63, 0, 62, 0, 61, 0, 60, + 0, 31, 15, 5, 63, 0, 64, 0, 65, 0, 66, 0, 119, 50, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.ssr_stec_correction.n_stub = 38; + + test_msg.ssr_stec_correction.stub[0] = 180; + + test_msg.ssr_stec_correction.stub[1] = 0; + + test_msg.ssr_stec_correction.stub[2] = 0; + + test_msg.ssr_stec_correction.stub[3] = 0; + + test_msg.ssr_stec_correction.stub[4] = 3; + + test_msg.ssr_stec_correction.stub[5] = 0; + + test_msg.ssr_stec_correction.stub[6] = 1; + + test_msg.ssr_stec_correction.stub[7] = 1; + + test_msg.ssr_stec_correction.stub[8] = 10; + + test_msg.ssr_stec_correction.stub[9] = 0; + + test_msg.ssr_stec_correction.stub[10] = 15; + + test_msg.ssr_stec_correction.stub[11] = 1; + + test_msg.ssr_stec_correction.stub[12] = 0; + + test_msg.ssr_stec_correction.stub[13] = 10; + + test_msg.ssr_stec_correction.stub[14] = 0; + + test_msg.ssr_stec_correction.stub[15] = 2; + + test_msg.ssr_stec_correction.stub[16] = 1; + + test_msg.ssr_stec_correction.stub[17] = 1; + + test_msg.ssr_stec_correction.stub[18] = 1; + + test_msg.ssr_stec_correction.stub[19] = 63; + + test_msg.ssr_stec_correction.stub[20] = 0; + + test_msg.ssr_stec_correction.stub[21] = 62; + + test_msg.ssr_stec_correction.stub[22] = 0; + + test_msg.ssr_stec_correction.stub[23] = 61; + + test_msg.ssr_stec_correction.stub[24] = 0; + + test_msg.ssr_stec_correction.stub[25] = 60; + + test_msg.ssr_stec_correction.stub[26] = 0; + + test_msg.ssr_stec_correction.stub[27] = 31; + + test_msg.ssr_stec_correction.stub[28] = 15; + + test_msg.ssr_stec_correction.stub[29] = 5; + + test_msg.ssr_stec_correction.stub[30] = 63; + + test_msg.ssr_stec_correction.stub[31] = 0; + + test_msg.ssr_stec_correction.stub[32] = 64; + + test_msg.ssr_stec_correction.stub[33] = 0; + + test_msg.ssr_stec_correction.stub[34] = 65; + + test_msg.ssr_stec_correction.stub[35] = 0; + + test_msg.ssr_stec_correction.stub[36] = 66; + + test_msg.ssr_stec_correction.stub[37] = 0; + + sbp_message_send(&sbp_state, SbpMsgSsrStecCorrection, 66, &test_msg, + &dummy_write); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff (expected: %zu, " + "actual: %zu)", + sizeof(encoded_frame), dummy_wr); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + + ck_assert_msg( + sbp_message_cmp(SbpMsgSsrStecCorrection, &last_msg.msg, &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg(last_msg.msg.ssr_stec_correction.n_stub == 38, + "incorrect value for " + "last_msg.msg.ssr_stec_correction.n_stub, expected 38, is %d", + last_msg.msg.ssr_stec_correction.n_stub); + + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[0] == 180, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[0], " + "expected 180, is %d", + last_msg.msg.ssr_stec_correction.stub[0]); + ck_assert_msg(last_msg.msg.ssr_stec_correction.stub[1] == 0, + "incorrect value for " + "last_msg.msg.ssr_stec_correction.stub[1], expected 0, is %d", + last_msg.msg.ssr_stec_correction.stub[1]); + ck_assert_msg(last_msg.msg.ssr_stec_correction.stub[2] == 0, + "incorrect value for " + "last_msg.msg.ssr_stec_correction.stub[2], expected 0, is %d", + last_msg.msg.ssr_stec_correction.stub[2]); + ck_assert_msg(last_msg.msg.ssr_stec_correction.stub[3] == 0, + "incorrect value for " + "last_msg.msg.ssr_stec_correction.stub[3], expected 0, is %d", + last_msg.msg.ssr_stec_correction.stub[3]); + ck_assert_msg(last_msg.msg.ssr_stec_correction.stub[4] == 3, + "incorrect value for " + "last_msg.msg.ssr_stec_correction.stub[4], expected 3, is %d", + last_msg.msg.ssr_stec_correction.stub[4]); + ck_assert_msg(last_msg.msg.ssr_stec_correction.stub[5] == 0, + "incorrect value for " + "last_msg.msg.ssr_stec_correction.stub[5], expected 0, is %d", + last_msg.msg.ssr_stec_correction.stub[5]); + ck_assert_msg(last_msg.msg.ssr_stec_correction.stub[6] == 1, + "incorrect value for " + "last_msg.msg.ssr_stec_correction.stub[6], expected 1, is %d", + last_msg.msg.ssr_stec_correction.stub[6]); + ck_assert_msg(last_msg.msg.ssr_stec_correction.stub[7] == 1, + "incorrect value for " + "last_msg.msg.ssr_stec_correction.stub[7], expected 1, is %d", + last_msg.msg.ssr_stec_correction.stub[7]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[8] == 10, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[8], " + "expected 10, is %d", + last_msg.msg.ssr_stec_correction.stub[8]); + ck_assert_msg(last_msg.msg.ssr_stec_correction.stub[9] == 0, + "incorrect value for " + "last_msg.msg.ssr_stec_correction.stub[9], expected 0, is %d", + last_msg.msg.ssr_stec_correction.stub[9]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[10] == 15, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[10], " + "expected 15, is %d", + last_msg.msg.ssr_stec_correction.stub[10]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[11] == 1, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[11], " + "expected 1, is %d", + last_msg.msg.ssr_stec_correction.stub[11]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[12] == 0, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[12], " + "expected 0, is %d", + last_msg.msg.ssr_stec_correction.stub[12]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[13] == 10, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[13], " + "expected 10, is %d", + last_msg.msg.ssr_stec_correction.stub[13]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[14] == 0, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[14], " + "expected 0, is %d", + last_msg.msg.ssr_stec_correction.stub[14]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[15] == 2, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[15], " + "expected 2, is %d", + last_msg.msg.ssr_stec_correction.stub[15]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[16] == 1, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[16], " + "expected 1, is %d", + last_msg.msg.ssr_stec_correction.stub[16]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[17] == 1, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[17], " + "expected 1, is %d", + last_msg.msg.ssr_stec_correction.stub[17]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[18] == 1, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[18], " + "expected 1, is %d", + last_msg.msg.ssr_stec_correction.stub[18]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[19] == 63, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[19], " + "expected 63, is %d", + last_msg.msg.ssr_stec_correction.stub[19]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[20] == 0, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[20], " + "expected 0, is %d", + last_msg.msg.ssr_stec_correction.stub[20]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[21] == 62, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[21], " + "expected 62, is %d", + last_msg.msg.ssr_stec_correction.stub[21]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[22] == 0, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[22], " + "expected 0, is %d", + last_msg.msg.ssr_stec_correction.stub[22]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[23] == 61, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[23], " + "expected 61, is %d", + last_msg.msg.ssr_stec_correction.stub[23]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[24] == 0, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[24], " + "expected 0, is %d", + last_msg.msg.ssr_stec_correction.stub[24]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[25] == 60, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[25], " + "expected 60, is %d", + last_msg.msg.ssr_stec_correction.stub[25]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[26] == 0, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[26], " + "expected 0, is %d", + last_msg.msg.ssr_stec_correction.stub[26]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[27] == 31, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[27], " + "expected 31, is %d", + last_msg.msg.ssr_stec_correction.stub[27]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[28] == 15, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[28], " + "expected 15, is %d", + last_msg.msg.ssr_stec_correction.stub[28]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[29] == 5, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[29], " + "expected 5, is %d", + last_msg.msg.ssr_stec_correction.stub[29]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[30] == 63, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[30], " + "expected 63, is %d", + last_msg.msg.ssr_stec_correction.stub[30]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[31] == 0, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[31], " + "expected 0, is %d", + last_msg.msg.ssr_stec_correction.stub[31]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[32] == 64, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[32], " + "expected 64, is %d", + last_msg.msg.ssr_stec_correction.stub[32]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[33] == 0, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[33], " + "expected 0, is %d", + last_msg.msg.ssr_stec_correction.stub[33]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[34] == 65, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[34], " + "expected 65, is %d", + last_msg.msg.ssr_stec_correction.stub[34]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[35] == 0, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[35], " + "expected 0, is %d", + last_msg.msg.ssr_stec_correction.stub[35]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[36] == 66, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[36], " + "expected 66, is %d", + last_msg.msg.ssr_stec_correction.stub[36]); + ck_assert_msg( + last_msg.msg.ssr_stec_correction.stub[37] == 0, + "incorrect value for last_msg.msg.ssr_stec_correction.stub[37], " + "expected 0, is %d", + last_msg.msg.ssr_stec_correction.stub[37]); + } +} +END_TEST + +Suite *auto_check_sbp_ssr_MsgSsrStecCorrection_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: auto_check_sbp_ssr_MsgSsrStecCorrection"); + TCase *tc_acq = + tcase_create("Automated_Suite_auto_check_sbp_ssr_MsgSsrStecCorrection"); + tcase_add_test(tc_acq, test_auto_check_sbp_ssr_MsgSsrStecCorrection); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/auto_check_sbp_ssr_MsgSsrTileDefinition.c b/c/test/auto_check_sbp_ssr_MsgSsrTileDefinition.c new file mode 100644 index 0000000000..c3ddd9e78a --- /dev/null +++ b/c/test/auto_check_sbp_ssr_MsgSsrTileDefinition.c @@ -0,0 +1,315 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrTileDefinition.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + sbp_msg_type_t msg_type; + sbp_msg_t msg; + void *context; +} last_msg; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static void *DUMMY_MEMORY_FOR_CALLBACKS = (void *)0xdeadbeef; +static void *DUMMY_MEMORY_FOR_IO = (void *)0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return (s32)real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return (s32)real_n; +} + +static void logging_reset() { memset(&last_msg, 0, sizeof(last_msg)); } + +static void msg_callback(u16 sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.msg_type = msg_type; + last_msg.msg = *msg; + last_msg.context = context; +} + +START_TEST(test_auto_check_sbp_ssr_MsgSsrTileDefinition) { + static sbp_msg_callbacks_node_t n; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_callback_register(&sbp_state, 1527, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 247, 5, 66, 0, 25, 31, 0, 1, 0, 2, 0, 4, 0, 8, 0, 16, + 0, 32, 0, 64, 0, 128, 210, 2, 150, 73, 0, 0, 0, 0, 214, 71, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.ssr_tile_definition.n_stub = 25; + + test_msg.ssr_tile_definition.stub[0] = 31; + + test_msg.ssr_tile_definition.stub[1] = 0; + + test_msg.ssr_tile_definition.stub[2] = 1; + + test_msg.ssr_tile_definition.stub[3] = 0; + + test_msg.ssr_tile_definition.stub[4] = 2; + + test_msg.ssr_tile_definition.stub[5] = 0; + + test_msg.ssr_tile_definition.stub[6] = 4; + + test_msg.ssr_tile_definition.stub[7] = 0; + + test_msg.ssr_tile_definition.stub[8] = 8; + + test_msg.ssr_tile_definition.stub[9] = 0; + + test_msg.ssr_tile_definition.stub[10] = 16; + + test_msg.ssr_tile_definition.stub[11] = 0; + + test_msg.ssr_tile_definition.stub[12] = 32; + + test_msg.ssr_tile_definition.stub[13] = 0; + + test_msg.ssr_tile_definition.stub[14] = 64; + + test_msg.ssr_tile_definition.stub[15] = 0; + + test_msg.ssr_tile_definition.stub[16] = 128; + + test_msg.ssr_tile_definition.stub[17] = 210; + + test_msg.ssr_tile_definition.stub[18] = 2; + + test_msg.ssr_tile_definition.stub[19] = 150; + + test_msg.ssr_tile_definition.stub[20] = 73; + + test_msg.ssr_tile_definition.stub[21] = 0; + + test_msg.ssr_tile_definition.stub[22] = 0; + + test_msg.ssr_tile_definition.stub[23] = 0; + + test_msg.ssr_tile_definition.stub[24] = 0; + + sbp_message_send(&sbp_state, SbpMsgSsrTileDefinition, 66, &test_msg, + &dummy_write); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff (expected: %zu, " + "actual: %zu)", + sizeof(encoded_frame), dummy_wr); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + + ck_assert_msg( + sbp_message_cmp(SbpMsgSsrTileDefinition, &last_msg.msg, &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg(last_msg.msg.ssr_tile_definition.n_stub == 25, + "incorrect value for " + "last_msg.msg.ssr_tile_definition.n_stub, expected 25, is %d", + last_msg.msg.ssr_tile_definition.n_stub); + + ck_assert_msg( + last_msg.msg.ssr_tile_definition.stub[0] == 31, + "incorrect value for last_msg.msg.ssr_tile_definition.stub[0], " + "expected 31, is %d", + last_msg.msg.ssr_tile_definition.stub[0]); + ck_assert_msg(last_msg.msg.ssr_tile_definition.stub[1] == 0, + "incorrect value for " + "last_msg.msg.ssr_tile_definition.stub[1], expected 0, is %d", + last_msg.msg.ssr_tile_definition.stub[1]); + ck_assert_msg(last_msg.msg.ssr_tile_definition.stub[2] == 1, + "incorrect value for " + "last_msg.msg.ssr_tile_definition.stub[2], expected 1, is %d", + last_msg.msg.ssr_tile_definition.stub[2]); + ck_assert_msg(last_msg.msg.ssr_tile_definition.stub[3] == 0, + "incorrect value for " + "last_msg.msg.ssr_tile_definition.stub[3], expected 0, is %d", + last_msg.msg.ssr_tile_definition.stub[3]); + ck_assert_msg(last_msg.msg.ssr_tile_definition.stub[4] == 2, + "incorrect value for " + "last_msg.msg.ssr_tile_definition.stub[4], expected 2, is %d", + last_msg.msg.ssr_tile_definition.stub[4]); + ck_assert_msg(last_msg.msg.ssr_tile_definition.stub[5] == 0, + "incorrect value for " + "last_msg.msg.ssr_tile_definition.stub[5], expected 0, is %d", + last_msg.msg.ssr_tile_definition.stub[5]); + ck_assert_msg(last_msg.msg.ssr_tile_definition.stub[6] == 4, + "incorrect value for " + "last_msg.msg.ssr_tile_definition.stub[6], expected 4, is %d", + last_msg.msg.ssr_tile_definition.stub[6]); + ck_assert_msg(last_msg.msg.ssr_tile_definition.stub[7] == 0, + "incorrect value for " + "last_msg.msg.ssr_tile_definition.stub[7], expected 0, is %d", + last_msg.msg.ssr_tile_definition.stub[7]); + ck_assert_msg(last_msg.msg.ssr_tile_definition.stub[8] == 8, + "incorrect value for " + "last_msg.msg.ssr_tile_definition.stub[8], expected 8, is %d", + last_msg.msg.ssr_tile_definition.stub[8]); + ck_assert_msg(last_msg.msg.ssr_tile_definition.stub[9] == 0, + "incorrect value for " + "last_msg.msg.ssr_tile_definition.stub[9], expected 0, is %d", + last_msg.msg.ssr_tile_definition.stub[9]); + ck_assert_msg( + last_msg.msg.ssr_tile_definition.stub[10] == 16, + "incorrect value for last_msg.msg.ssr_tile_definition.stub[10], " + "expected 16, is %d", + last_msg.msg.ssr_tile_definition.stub[10]); + ck_assert_msg( + last_msg.msg.ssr_tile_definition.stub[11] == 0, + "incorrect value for last_msg.msg.ssr_tile_definition.stub[11], " + "expected 0, is %d", + last_msg.msg.ssr_tile_definition.stub[11]); + ck_assert_msg( + last_msg.msg.ssr_tile_definition.stub[12] == 32, + "incorrect value for last_msg.msg.ssr_tile_definition.stub[12], " + "expected 32, is %d", + last_msg.msg.ssr_tile_definition.stub[12]); + ck_assert_msg( + last_msg.msg.ssr_tile_definition.stub[13] == 0, + "incorrect value for last_msg.msg.ssr_tile_definition.stub[13], " + "expected 0, is %d", + last_msg.msg.ssr_tile_definition.stub[13]); + ck_assert_msg( + last_msg.msg.ssr_tile_definition.stub[14] == 64, + "incorrect value for last_msg.msg.ssr_tile_definition.stub[14], " + "expected 64, is %d", + last_msg.msg.ssr_tile_definition.stub[14]); + ck_assert_msg( + last_msg.msg.ssr_tile_definition.stub[15] == 0, + "incorrect value for last_msg.msg.ssr_tile_definition.stub[15], " + "expected 0, is %d", + last_msg.msg.ssr_tile_definition.stub[15]); + ck_assert_msg( + last_msg.msg.ssr_tile_definition.stub[16] == 128, + "incorrect value for last_msg.msg.ssr_tile_definition.stub[16], " + "expected 128, is %d", + last_msg.msg.ssr_tile_definition.stub[16]); + ck_assert_msg( + last_msg.msg.ssr_tile_definition.stub[17] == 210, + "incorrect value for last_msg.msg.ssr_tile_definition.stub[17], " + "expected 210, is %d", + last_msg.msg.ssr_tile_definition.stub[17]); + ck_assert_msg( + last_msg.msg.ssr_tile_definition.stub[18] == 2, + "incorrect value for last_msg.msg.ssr_tile_definition.stub[18], " + "expected 2, is %d", + last_msg.msg.ssr_tile_definition.stub[18]); + ck_assert_msg( + last_msg.msg.ssr_tile_definition.stub[19] == 150, + "incorrect value for last_msg.msg.ssr_tile_definition.stub[19], " + "expected 150, is %d", + last_msg.msg.ssr_tile_definition.stub[19]); + ck_assert_msg( + last_msg.msg.ssr_tile_definition.stub[20] == 73, + "incorrect value for last_msg.msg.ssr_tile_definition.stub[20], " + "expected 73, is %d", + last_msg.msg.ssr_tile_definition.stub[20]); + ck_assert_msg( + last_msg.msg.ssr_tile_definition.stub[21] == 0, + "incorrect value for last_msg.msg.ssr_tile_definition.stub[21], " + "expected 0, is %d", + last_msg.msg.ssr_tile_definition.stub[21]); + ck_assert_msg( + last_msg.msg.ssr_tile_definition.stub[22] == 0, + "incorrect value for last_msg.msg.ssr_tile_definition.stub[22], " + "expected 0, is %d", + last_msg.msg.ssr_tile_definition.stub[22]); + ck_assert_msg( + last_msg.msg.ssr_tile_definition.stub[23] == 0, + "incorrect value for last_msg.msg.ssr_tile_definition.stub[23], " + "expected 0, is %d", + last_msg.msg.ssr_tile_definition.stub[23]); + ck_assert_msg( + last_msg.msg.ssr_tile_definition.stub[24] == 0, + "incorrect value for last_msg.msg.ssr_tile_definition.stub[24], " + "expected 0, is %d", + last_msg.msg.ssr_tile_definition.stub[24]); + } +} +END_TEST + +Suite *auto_check_sbp_ssr_MsgSsrTileDefinition_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: auto_check_sbp_ssr_MsgSsrTileDefinition"); + TCase *tc_acq = + tcase_create("Automated_Suite_auto_check_sbp_ssr_MsgSsrTileDefinition"); + tcase_add_test(tc_acq, test_auto_check_sbp_ssr_MsgSsrTileDefinition); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/check_main.c b/c/test/check_main.c index 7110851069..79ee60c34e 100644 --- a/c/test/check_main.c +++ b/c/test/check_main.c @@ -34,6 +34,16 @@ int main(void) { srunner_add_suite(sr, auto_check_sbp_file_io_MsgFileioWriteResp_suite()); srunner_add_suite(sr, auto_check_sbp_imu_MsgImuAux_suite()); srunner_add_suite(sr, auto_check_sbp_imu_MsgImuRaw_suite()); + srunner_add_suite(sr, auto_check_sbp_integrity_MsgSsrFlagHighLevel_suite()); + srunner_add_suite( + sr, auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos_suite()); + srunner_add_suite(sr, + auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints_suite()); + srunner_add_suite(sr, + auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos_suite()); + srunner_add_suite(sr, auto_check_sbp_integrity_MsgSsrFlagSatellites_suite()); + srunner_add_suite(sr, + auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints_suite()); srunner_add_suite(sr, auto_check_sbp_logging_MsgFwd_suite()); srunner_add_suite(sr, auto_check_sbp_logging_MsgLog_suite()); srunner_add_suite(sr, auto_check_sbp_logging_MsgPrintDep_suite()); @@ -44,9 +54,11 @@ int main(void) { srunner_add_suite(sr, auto_check_sbp_navigation_MsgBaselineNEDDepA_suite()); srunner_add_suite(sr, auto_check_sbp_navigation_MsgDops_suite()); srunner_add_suite(sr, auto_check_sbp_navigation_MsgDopsDepA_suite()); + srunner_add_suite(sr, auto_check_sbp_navigation_MsgGPSLeapSecond_suite()); srunner_add_suite(sr, auto_check_sbp_navigation_MsgGPSTime_suite()); srunner_add_suite(sr, auto_check_sbp_navigation_MsgGPSTimeDepA_suite()); srunner_add_suite(sr, auto_check_sbp_navigation_MsgGPSTimeGNSS_suite()); + srunner_add_suite(sr, auto_check_sbp_navigation_MsgItrf_suite()); srunner_add_suite(sr, auto_check_sbp_navigation_MsgPosECEF_suite()); srunner_add_suite(sr, auto_check_sbp_navigation_MsgPosECEFCov_suite()); srunner_add_suite(sr, auto_check_sbp_navigation_MsgPosECEFCovGNSS_suite()); @@ -100,6 +112,14 @@ int main(void) { auto_check_sbp_settings_MsgSettingsReadByIndexDone_suite()); srunner_add_suite(sr, auto_check_sbp_settings_MsgSettingsReadByIndexResp_suite()); + srunner_add_suite(sr, auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds_suite()); + srunner_add_suite(sr, + auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds_suite()); + srunner_add_suite(sr, auto_check_sbp_ssr_MsgSsrOrbitClockBounds_suite()); + srunner_add_suite( + sr, auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation_suite()); + srunner_add_suite(sr, auto_check_sbp_ssr_MsgSsrStecCorrection_suite()); + srunner_add_suite(sr, auto_check_sbp_ssr_MsgSsrTileDefinition_suite()); srunner_add_suite(sr, auto_check_sbp_system_MsgDgnssStatus_suite()); srunner_add_suite(sr, auto_check_sbp_system_MsgGroupMeta_suite()); srunner_add_suite(sr, auto_check_sbp_system_MsgHeartbeat_suite()); diff --git a/c/test/check_main_legacy.c b/c/test/check_main_legacy.c index c3ea95d7ae..a76b0e6fee 100644 --- a/c/test/check_main_legacy.c +++ b/c/test/check_main_legacy.c @@ -38,6 +38,19 @@ int main(void) { legacy_auto_check_sbp_file_io_MsgFileioWriteResp_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_imu_MsgImuAux_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_imu_MsgImuRaw_suite()); + srunner_add_suite( + sr, legacy_auto_check_sbp_integrity_MsgSsrFlagHighLevel_suite()); + srunner_add_suite( + sr, + legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos_suite()); + srunner_add_suite( + sr, legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints_suite()); + srunner_add_suite( + sr, legacy_auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos_suite()); + srunner_add_suite( + sr, legacy_auto_check_sbp_integrity_MsgSsrFlagSatellites_suite()); + srunner_add_suite( + sr, legacy_auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_logging_MsgFwd_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_logging_MsgLog_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_logging_MsgPrintDep_suite()); @@ -53,11 +66,14 @@ int main(void) { sr, legacy_auto_check_sbp_navigation_MsgBaselineNEDDepA_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_navigation_MsgDops_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_navigation_MsgDopsDepA_suite()); + srunner_add_suite(sr, + legacy_auto_check_sbp_navigation_MsgGPSLeapSecond_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_navigation_MsgGPSTime_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_navigation_MsgGPSTimeDepA_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_navigation_MsgGPSTimeGNSS_suite()); + srunner_add_suite(sr, legacy_auto_check_sbp_navigation_MsgItrf_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_navigation_MsgPosECEF_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_navigation_MsgPosECEFCov_suite()); srunner_add_suite(sr, @@ -132,6 +148,16 @@ int main(void) { sr, legacy_auto_check_sbp_settings_MsgSettingsReadByIndexDone_suite()); srunner_add_suite( sr, legacy_auto_check_sbp_settings_MsgSettingsReadByIndexResp_suite()); + srunner_add_suite( + sr, legacy_auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds_suite()); + srunner_add_suite( + sr, legacy_auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds_suite()); + srunner_add_suite(sr, + legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBounds_suite()); + srunner_add_suite( + sr, legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation_suite()); + srunner_add_suite(sr, legacy_auto_check_sbp_ssr_MsgSsrStecCorrection_suite()); + srunner_add_suite(sr, legacy_auto_check_sbp_ssr_MsgSsrTileDefinition_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_system_MsgDgnssStatus_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_system_MsgGroupMeta_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_system_MsgHeartbeat_suite()); diff --git a/c/test/check_suites.h b/c/test/check_suites.h index 23044867a1..1122423621 100644 --- a/c/test/check_suites.h +++ b/c/test/check_suites.h @@ -26,6 +26,12 @@ Suite* auto_check_sbp_ext_events_MsgExtEvent_suite(void); Suite* auto_check_sbp_file_io_MsgFileioWriteResp_suite(void); Suite* auto_check_sbp_imu_MsgImuAux_suite(void); Suite* auto_check_sbp_imu_MsgImuRaw_suite(void); +Suite* auto_check_sbp_integrity_MsgSsrFlagHighLevel_suite(void); +Suite* auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos_suite(void); +Suite* auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints_suite(void); +Suite* auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos_suite(void); +Suite* auto_check_sbp_integrity_MsgSsrFlagSatellites_suite(void); +Suite* auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints_suite(void); Suite* auto_check_sbp_logging_MsgFwd_suite(void); Suite* auto_check_sbp_logging_MsgLog_suite(void); Suite* auto_check_sbp_logging_MsgPrintDep_suite(void); @@ -36,9 +42,11 @@ Suite* auto_check_sbp_navigation_MsgBaselineNED_suite(void); Suite* auto_check_sbp_navigation_MsgBaselineNEDDepA_suite(void); Suite* auto_check_sbp_navigation_MsgDops_suite(void); Suite* auto_check_sbp_navigation_MsgDopsDepA_suite(void); +Suite* auto_check_sbp_navigation_MsgGPSLeapSecond_suite(void); Suite* auto_check_sbp_navigation_MsgGPSTime_suite(void); Suite* auto_check_sbp_navigation_MsgGPSTimeDepA_suite(void); Suite* auto_check_sbp_navigation_MsgGPSTimeGNSS_suite(void); +Suite* auto_check_sbp_navigation_MsgItrf_suite(void); Suite* auto_check_sbp_navigation_MsgPosECEF_suite(void); Suite* auto_check_sbp_navigation_MsgPosECEFCov_suite(void); Suite* auto_check_sbp_navigation_MsgPosECEFCovGNSS_suite(void); @@ -90,6 +98,12 @@ Suite* auto_check_sbp_piksi_MsgUartStateDepA_suite(void); Suite* auto_check_sbp_sbas_MsgSbasRaw_suite(void); Suite* auto_check_sbp_settings_MsgSettingsReadByIndexDone_suite(void); Suite* auto_check_sbp_settings_MsgSettingsReadByIndexResp_suite(void); +Suite* auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds_suite(void); +Suite* auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds_suite(void); +Suite* auto_check_sbp_ssr_MsgSsrOrbitClockBounds_suite(void); +Suite* auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation_suite(void); +Suite* auto_check_sbp_ssr_MsgSsrStecCorrection_suite(void); +Suite* auto_check_sbp_ssr_MsgSsrTileDefinition_suite(void); Suite* auto_check_sbp_system_MsgDgnssStatus_suite(void); Suite* auto_check_sbp_system_MsgGroupMeta_suite(void); Suite* auto_check_sbp_system_MsgHeartbeat_suite(void); diff --git a/c/test/check_suites_legacy.h b/c/test/check_suites_legacy.h index 2fa45ab464..f18f0e3281 100644 --- a/c/test/check_suites_legacy.h +++ b/c/test/check_suites_legacy.h @@ -26,6 +26,13 @@ Suite* legacy_auto_check_sbp_ext_events_MsgExtEvent_suite(void); Suite* legacy_auto_check_sbp_file_io_MsgFileioWriteResp_suite(void); Suite* legacy_auto_check_sbp_imu_MsgImuAux_suite(void); Suite* legacy_auto_check_sbp_imu_MsgImuRaw_suite(void); +Suite* legacy_auto_check_sbp_integrity_MsgSsrFlagHighLevel_suite(void); +Suite* legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos_suite( + void); +Suite* legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints_suite(void); +Suite* legacy_auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos_suite(void); +Suite* legacy_auto_check_sbp_integrity_MsgSsrFlagSatellites_suite(void); +Suite* legacy_auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints_suite(void); Suite* legacy_auto_check_sbp_logging_MsgFwd_suite(void); Suite* legacy_auto_check_sbp_logging_MsgLog_suite(void); Suite* legacy_auto_check_sbp_logging_MsgPrintDep_suite(void); @@ -36,9 +43,11 @@ Suite* legacy_auto_check_sbp_navigation_MsgBaselineNED_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgBaselineNEDDepA_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgDops_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgDopsDepA_suite(void); +Suite* legacy_auto_check_sbp_navigation_MsgGPSLeapSecond_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgGPSTime_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgGPSTimeDepA_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgGPSTimeGNSS_suite(void); +Suite* legacy_auto_check_sbp_navigation_MsgItrf_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgPosECEF_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgPosECEFCov_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgPosECEFCovGNSS_suite(void); @@ -90,6 +99,12 @@ Suite* legacy_auto_check_sbp_piksi_MsgUartStateDepA_suite(void); Suite* legacy_auto_check_sbp_sbas_MsgSbasRaw_suite(void); Suite* legacy_auto_check_sbp_settings_MsgSettingsReadByIndexDone_suite(void); Suite* legacy_auto_check_sbp_settings_MsgSettingsReadByIndexResp_suite(void); +Suite* legacy_auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds_suite(void); +Suite* legacy_auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds_suite(void); +Suite* legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBounds_suite(void); +Suite* legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation_suite(void); +Suite* legacy_auto_check_sbp_ssr_MsgSsrStecCorrection_suite(void); +Suite* legacy_auto_check_sbp_ssr_MsgSsrTileDefinition_suite(void); Suite* legacy_auto_check_sbp_system_MsgDgnssStatus_suite(void); Suite* legacy_auto_check_sbp_system_MsgGroupMeta_suite(void); Suite* legacy_auto_check_sbp_system_MsgHeartbeat_suite(void); diff --git a/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc new file mode 100644 index 0000000000..d6cef43281 --- /dev/null +++ b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc @@ -0,0 +1,256 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +#include +class Test_auto_check_sbp_integrity_MsgSsrFlagHighLevel0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::MessageHandler { + public: + Test_auto_check_sbp_integrity_MsgSsrFlagHighLevel0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::MessageHandler(this), + last_msg_(), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, + const sbp_msg_ssr_flag_high_level_t &msg) override { + last_msg_ = msg; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + sbp_msg_ssr_flag_high_level_t last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_auto_check_sbp_integrity_MsgSsrFlagHighLevel0, Test) { + uint8_t encoded_frame[] = { + 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, + 0, 30, 0, 40, 1, 2, 3, 0, 0, 0, 0, 0, 0, 4, 5, 6, 7, 102, 67, + }; + + sbp_msg_ssr_flag_high_level_t test_msg{}; + test_msg.n_stub = 31; + + test_msg.stub[0] = 180; + + test_msg.stub[1] = 0; + + test_msg.stub[2] = 0; + + test_msg.stub[3] = 0; + + test_msg.stub[4] = 3; + + test_msg.stub[5] = 0; + + test_msg.stub[6] = 104; + + test_msg.stub[7] = 1; + + test_msg.stub[8] = 0; + + test_msg.stub[9] = 0; + + test_msg.stub[10] = 6; + + test_msg.stub[11] = 0; + + test_msg.stub[12] = 10; + + test_msg.stub[13] = 20; + + test_msg.stub[14] = 0; + + test_msg.stub[15] = 30; + + test_msg.stub[16] = 0; + + test_msg.stub[17] = 40; + + test_msg.stub[18] = 1; + + test_msg.stub[19] = 2; + + test_msg.stub[20] = 3; + + test_msg.stub[21] = 0; + + test_msg.stub[22] = 0; + + test_msg.stub[23] = 0; + + test_msg.stub[24] = 0; + + test_msg.stub[25] = 0; + + test_msg.stub[26] = 0; + + test_msg.stub[27] = 4; + + test_msg.stub[28] = 5; + + test_msg.stub[29] = 6; + + test_msg.stub[30] = 7; + + EXPECT_EQ(send_message(66, test_msg), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_, test_msg); + EXPECT_EQ(last_msg_.n_stub, 31) + << "incorrect value for last_msg_.n_stub, expected 31, is " + << last_msg_.n_stub; + EXPECT_EQ(last_msg_.stub[0], 180) + << "incorrect value for last_msg_.stub[0], expected 180, is " + << last_msg_.stub[0]; + EXPECT_EQ(last_msg_.stub[1], 0) + << "incorrect value for last_msg_.stub[1], expected 0, is " + << last_msg_.stub[1]; + EXPECT_EQ(last_msg_.stub[2], 0) + << "incorrect value for last_msg_.stub[2], expected 0, is " + << last_msg_.stub[2]; + EXPECT_EQ(last_msg_.stub[3], 0) + << "incorrect value for last_msg_.stub[3], expected 0, is " + << last_msg_.stub[3]; + EXPECT_EQ(last_msg_.stub[4], 3) + << "incorrect value for last_msg_.stub[4], expected 3, is " + << last_msg_.stub[4]; + EXPECT_EQ(last_msg_.stub[5], 0) + << "incorrect value for last_msg_.stub[5], expected 0, is " + << last_msg_.stub[5]; + EXPECT_EQ(last_msg_.stub[6], 104) + << "incorrect value for last_msg_.stub[6], expected 104, is " + << last_msg_.stub[6]; + EXPECT_EQ(last_msg_.stub[7], 1) + << "incorrect value for last_msg_.stub[7], expected 1, is " + << last_msg_.stub[7]; + EXPECT_EQ(last_msg_.stub[8], 0) + << "incorrect value for last_msg_.stub[8], expected 0, is " + << last_msg_.stub[8]; + EXPECT_EQ(last_msg_.stub[9], 0) + << "incorrect value for last_msg_.stub[9], expected 0, is " + << last_msg_.stub[9]; + EXPECT_EQ(last_msg_.stub[10], 6) + << "incorrect value for last_msg_.stub[10], expected 6, is " + << last_msg_.stub[10]; + EXPECT_EQ(last_msg_.stub[11], 0) + << "incorrect value for last_msg_.stub[11], expected 0, is " + << last_msg_.stub[11]; + EXPECT_EQ(last_msg_.stub[12], 10) + << "incorrect value for last_msg_.stub[12], expected 10, is " + << last_msg_.stub[12]; + EXPECT_EQ(last_msg_.stub[13], 20) + << "incorrect value for last_msg_.stub[13], expected 20, is " + << last_msg_.stub[13]; + EXPECT_EQ(last_msg_.stub[14], 0) + << "incorrect value for last_msg_.stub[14], expected 0, is " + << last_msg_.stub[14]; + EXPECT_EQ(last_msg_.stub[15], 30) + << "incorrect value for last_msg_.stub[15], expected 30, is " + << last_msg_.stub[15]; + EXPECT_EQ(last_msg_.stub[16], 0) + << "incorrect value for last_msg_.stub[16], expected 0, is " + << last_msg_.stub[16]; + EXPECT_EQ(last_msg_.stub[17], 40) + << "incorrect value for last_msg_.stub[17], expected 40, is " + << last_msg_.stub[17]; + EXPECT_EQ(last_msg_.stub[18], 1) + << "incorrect value for last_msg_.stub[18], expected 1, is " + << last_msg_.stub[18]; + EXPECT_EQ(last_msg_.stub[19], 2) + << "incorrect value for last_msg_.stub[19], expected 2, is " + << last_msg_.stub[19]; + EXPECT_EQ(last_msg_.stub[20], 3) + << "incorrect value for last_msg_.stub[20], expected 3, is " + << last_msg_.stub[20]; + EXPECT_EQ(last_msg_.stub[21], 0) + << "incorrect value for last_msg_.stub[21], expected 0, is " + << last_msg_.stub[21]; + EXPECT_EQ(last_msg_.stub[22], 0) + << "incorrect value for last_msg_.stub[22], expected 0, is " + << last_msg_.stub[22]; + EXPECT_EQ(last_msg_.stub[23], 0) + << "incorrect value for last_msg_.stub[23], expected 0, is " + << last_msg_.stub[23]; + EXPECT_EQ(last_msg_.stub[24], 0) + << "incorrect value for last_msg_.stub[24], expected 0, is " + << last_msg_.stub[24]; + EXPECT_EQ(last_msg_.stub[25], 0) + << "incorrect value for last_msg_.stub[25], expected 0, is " + << last_msg_.stub[25]; + EXPECT_EQ(last_msg_.stub[26], 0) + << "incorrect value for last_msg_.stub[26], expected 0, is " + << last_msg_.stub[26]; + EXPECT_EQ(last_msg_.stub[27], 4) + << "incorrect value for last_msg_.stub[27], expected 4, is " + << last_msg_.stub[27]; + EXPECT_EQ(last_msg_.stub[28], 5) + << "incorrect value for last_msg_.stub[28], expected 5, is " + << last_msg_.stub[28]; + EXPECT_EQ(last_msg_.stub[29], 6) + << "incorrect value for last_msg_.stub[29], expected 6, is " + << last_msg_.stub[29]; + EXPECT_EQ(last_msg_.stub[30], 7) + << "incorrect value for last_msg_.stub[30], expected 7, is " + << last_msg_.stub[30]; +} diff --git a/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos.cc b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos.cc new file mode 100644 index 0000000000..0bf2ad4b37 --- /dev/null +++ b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos.cc @@ -0,0 +1,207 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPointSatLos.yaml +// by generate.py. Do not modify by hand! + +#include +#include +#include +#include +#include +class Test_auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::MessageHandler { + public: + Test_auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::MessageHandler(this), + last_msg_(), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg( + uint16_t sender_id, + const sbp_msg_ssr_flag_iono_grid_point_sat_los_t &msg) override { + last_msg_ = msg; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + sbp_msg_ssr_flag_iono_grid_point_sat_los_t last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos0, Test) { + uint8_t encoded_frame[] = { + 85, 209, 11, 66, 0, 21, 180, 0, 0, 0, 3, 0, 1, 2, 3, + 4, 0, 5, 0, 6, 30, 0, 2, 10, 11, 15, 14, 98, 148, + }; + + sbp_msg_ssr_flag_iono_grid_point_sat_los_t test_msg{}; + test_msg.n_stub = 21; + + test_msg.stub[0] = 180; + + test_msg.stub[1] = 0; + + test_msg.stub[2] = 0; + + test_msg.stub[3] = 0; + + test_msg.stub[4] = 3; + + test_msg.stub[5] = 0; + + test_msg.stub[6] = 1; + + test_msg.stub[7] = 2; + + test_msg.stub[8] = 3; + + test_msg.stub[9] = 4; + + test_msg.stub[10] = 0; + + test_msg.stub[11] = 5; + + test_msg.stub[12] = 0; + + test_msg.stub[13] = 6; + + test_msg.stub[14] = 30; + + test_msg.stub[15] = 0; + + test_msg.stub[16] = 2; + + test_msg.stub[17] = 10; + + test_msg.stub[18] = 11; + + test_msg.stub[19] = 15; + + test_msg.stub[20] = 14; + + EXPECT_EQ(send_message(66, test_msg), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_, test_msg); + EXPECT_EQ(last_msg_.n_stub, 21) + << "incorrect value for last_msg_.n_stub, expected 21, is " + << last_msg_.n_stub; + EXPECT_EQ(last_msg_.stub[0], 180) + << "incorrect value for last_msg_.stub[0], expected 180, is " + << last_msg_.stub[0]; + EXPECT_EQ(last_msg_.stub[1], 0) + << "incorrect value for last_msg_.stub[1], expected 0, is " + << last_msg_.stub[1]; + EXPECT_EQ(last_msg_.stub[2], 0) + << "incorrect value for last_msg_.stub[2], expected 0, is " + << last_msg_.stub[2]; + EXPECT_EQ(last_msg_.stub[3], 0) + << "incorrect value for last_msg_.stub[3], expected 0, is " + << last_msg_.stub[3]; + EXPECT_EQ(last_msg_.stub[4], 3) + << "incorrect value for last_msg_.stub[4], expected 3, is " + << last_msg_.stub[4]; + EXPECT_EQ(last_msg_.stub[5], 0) + << "incorrect value for last_msg_.stub[5], expected 0, is " + << last_msg_.stub[5]; + EXPECT_EQ(last_msg_.stub[6], 1) + << "incorrect value for last_msg_.stub[6], expected 1, is " + << last_msg_.stub[6]; + EXPECT_EQ(last_msg_.stub[7], 2) + << "incorrect value for last_msg_.stub[7], expected 2, is " + << last_msg_.stub[7]; + EXPECT_EQ(last_msg_.stub[8], 3) + << "incorrect value for last_msg_.stub[8], expected 3, is " + << last_msg_.stub[8]; + EXPECT_EQ(last_msg_.stub[9], 4) + << "incorrect value for last_msg_.stub[9], expected 4, is " + << last_msg_.stub[9]; + EXPECT_EQ(last_msg_.stub[10], 0) + << "incorrect value for last_msg_.stub[10], expected 0, is " + << last_msg_.stub[10]; + EXPECT_EQ(last_msg_.stub[11], 5) + << "incorrect value for last_msg_.stub[11], expected 5, is " + << last_msg_.stub[11]; + EXPECT_EQ(last_msg_.stub[12], 0) + << "incorrect value for last_msg_.stub[12], expected 0, is " + << last_msg_.stub[12]; + EXPECT_EQ(last_msg_.stub[13], 6) + << "incorrect value for last_msg_.stub[13], expected 6, is " + << last_msg_.stub[13]; + EXPECT_EQ(last_msg_.stub[14], 30) + << "incorrect value for last_msg_.stub[14], expected 30, is " + << last_msg_.stub[14]; + EXPECT_EQ(last_msg_.stub[15], 0) + << "incorrect value for last_msg_.stub[15], expected 0, is " + << last_msg_.stub[15]; + EXPECT_EQ(last_msg_.stub[16], 2) + << "incorrect value for last_msg_.stub[16], expected 2, is " + << last_msg_.stub[16]; + EXPECT_EQ(last_msg_.stub[17], 10) + << "incorrect value for last_msg_.stub[17], expected 10, is " + << last_msg_.stub[17]; + EXPECT_EQ(last_msg_.stub[18], 11) + << "incorrect value for last_msg_.stub[18], expected 11, is " + << last_msg_.stub[18]; + EXPECT_EQ(last_msg_.stub[19], 15) + << "incorrect value for last_msg_.stub[19], expected 15, is " + << last_msg_.stub[19]; + EXPECT_EQ(last_msg_.stub[20], 14) + << "incorrect value for last_msg_.stub[20], expected 14, is " + << last_msg_.stub[20]; +} diff --git a/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints.cc b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints.cc new file mode 100644 index 0000000000..dcc61b7748 --- /dev/null +++ b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints.cc @@ -0,0 +1,206 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPoints.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +#include +class Test_auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::MessageHandler { + public: + Test_auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::MessageHandler(this), + last_msg_(), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, + const sbp_msg_ssr_flag_iono_grid_points_t &msg) override { + last_msg_ = msg; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + sbp_msg_ssr_flag_iono_grid_points_t last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints0, Test) { + uint8_t encoded_frame[] = { + 85, 199, 11, 66, 0, 21, 180, 0, 0, 0, 3, 0, 1, 2, 3, + 4, 0, 5, 0, 6, 3, 10, 0, 11, 0, 12, 0, 53, 7, + }; + + sbp_msg_ssr_flag_iono_grid_points_t test_msg{}; + test_msg.n_stub = 21; + + test_msg.stub[0] = 180; + + test_msg.stub[1] = 0; + + test_msg.stub[2] = 0; + + test_msg.stub[3] = 0; + + test_msg.stub[4] = 3; + + test_msg.stub[5] = 0; + + test_msg.stub[6] = 1; + + test_msg.stub[7] = 2; + + test_msg.stub[8] = 3; + + test_msg.stub[9] = 4; + + test_msg.stub[10] = 0; + + test_msg.stub[11] = 5; + + test_msg.stub[12] = 0; + + test_msg.stub[13] = 6; + + test_msg.stub[14] = 3; + + test_msg.stub[15] = 10; + + test_msg.stub[16] = 0; + + test_msg.stub[17] = 11; + + test_msg.stub[18] = 0; + + test_msg.stub[19] = 12; + + test_msg.stub[20] = 0; + + EXPECT_EQ(send_message(66, test_msg), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_, test_msg); + EXPECT_EQ(last_msg_.n_stub, 21) + << "incorrect value for last_msg_.n_stub, expected 21, is " + << last_msg_.n_stub; + EXPECT_EQ(last_msg_.stub[0], 180) + << "incorrect value for last_msg_.stub[0], expected 180, is " + << last_msg_.stub[0]; + EXPECT_EQ(last_msg_.stub[1], 0) + << "incorrect value for last_msg_.stub[1], expected 0, is " + << last_msg_.stub[1]; + EXPECT_EQ(last_msg_.stub[2], 0) + << "incorrect value for last_msg_.stub[2], expected 0, is " + << last_msg_.stub[2]; + EXPECT_EQ(last_msg_.stub[3], 0) + << "incorrect value for last_msg_.stub[3], expected 0, is " + << last_msg_.stub[3]; + EXPECT_EQ(last_msg_.stub[4], 3) + << "incorrect value for last_msg_.stub[4], expected 3, is " + << last_msg_.stub[4]; + EXPECT_EQ(last_msg_.stub[5], 0) + << "incorrect value for last_msg_.stub[5], expected 0, is " + << last_msg_.stub[5]; + EXPECT_EQ(last_msg_.stub[6], 1) + << "incorrect value for last_msg_.stub[6], expected 1, is " + << last_msg_.stub[6]; + EXPECT_EQ(last_msg_.stub[7], 2) + << "incorrect value for last_msg_.stub[7], expected 2, is " + << last_msg_.stub[7]; + EXPECT_EQ(last_msg_.stub[8], 3) + << "incorrect value for last_msg_.stub[8], expected 3, is " + << last_msg_.stub[8]; + EXPECT_EQ(last_msg_.stub[9], 4) + << "incorrect value for last_msg_.stub[9], expected 4, is " + << last_msg_.stub[9]; + EXPECT_EQ(last_msg_.stub[10], 0) + << "incorrect value for last_msg_.stub[10], expected 0, is " + << last_msg_.stub[10]; + EXPECT_EQ(last_msg_.stub[11], 5) + << "incorrect value for last_msg_.stub[11], expected 5, is " + << last_msg_.stub[11]; + EXPECT_EQ(last_msg_.stub[12], 0) + << "incorrect value for last_msg_.stub[12], expected 0, is " + << last_msg_.stub[12]; + EXPECT_EQ(last_msg_.stub[13], 6) + << "incorrect value for last_msg_.stub[13], expected 6, is " + << last_msg_.stub[13]; + EXPECT_EQ(last_msg_.stub[14], 3) + << "incorrect value for last_msg_.stub[14], expected 3, is " + << last_msg_.stub[14]; + EXPECT_EQ(last_msg_.stub[15], 10) + << "incorrect value for last_msg_.stub[15], expected 10, is " + << last_msg_.stub[15]; + EXPECT_EQ(last_msg_.stub[16], 0) + << "incorrect value for last_msg_.stub[16], expected 0, is " + << last_msg_.stub[16]; + EXPECT_EQ(last_msg_.stub[17], 11) + << "incorrect value for last_msg_.stub[17], expected 11, is " + << last_msg_.stub[17]; + EXPECT_EQ(last_msg_.stub[18], 0) + << "incorrect value for last_msg_.stub[18], expected 0, is " + << last_msg_.stub[18]; + EXPECT_EQ(last_msg_.stub[19], 12) + << "incorrect value for last_msg_.stub[19], expected 12, is " + << last_msg_.stub[19]; + EXPECT_EQ(last_msg_.stub[20], 0) + << "incorrect value for last_msg_.stub[20], expected 0, is " + << last_msg_.stub[20]; +} diff --git a/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos.cc b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos.cc new file mode 100644 index 0000000000..5458c42075 --- /dev/null +++ b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos.cc @@ -0,0 +1,197 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoTileSatLos.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +#include +class Test_auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::MessageHandler { + public: + Test_auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::MessageHandler(this), + last_msg_(), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg( + uint16_t sender_id, + const sbp_msg_ssr_flag_iono_tile_sat_los_t &msg) override { + last_msg_ = msg; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + sbp_msg_ssr_flag_iono_tile_sat_los_t last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos0, Test) { + uint8_t encoded_frame[] = { + 85, 205, 11, 66, 0, 19, 180, 0, 0, 0, 3, 0, 1, 2, + 3, 4, 0, 5, 0, 6, 2, 10, 11, 15, 14, 239, 235, + }; + + sbp_msg_ssr_flag_iono_tile_sat_los_t test_msg{}; + test_msg.n_stub = 19; + + test_msg.stub[0] = 180; + + test_msg.stub[1] = 0; + + test_msg.stub[2] = 0; + + test_msg.stub[3] = 0; + + test_msg.stub[4] = 3; + + test_msg.stub[5] = 0; + + test_msg.stub[6] = 1; + + test_msg.stub[7] = 2; + + test_msg.stub[8] = 3; + + test_msg.stub[9] = 4; + + test_msg.stub[10] = 0; + + test_msg.stub[11] = 5; + + test_msg.stub[12] = 0; + + test_msg.stub[13] = 6; + + test_msg.stub[14] = 2; + + test_msg.stub[15] = 10; + + test_msg.stub[16] = 11; + + test_msg.stub[17] = 15; + + test_msg.stub[18] = 14; + + EXPECT_EQ(send_message(66, test_msg), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_, test_msg); + EXPECT_EQ(last_msg_.n_stub, 19) + << "incorrect value for last_msg_.n_stub, expected 19, is " + << last_msg_.n_stub; + EXPECT_EQ(last_msg_.stub[0], 180) + << "incorrect value for last_msg_.stub[0], expected 180, is " + << last_msg_.stub[0]; + EXPECT_EQ(last_msg_.stub[1], 0) + << "incorrect value for last_msg_.stub[1], expected 0, is " + << last_msg_.stub[1]; + EXPECT_EQ(last_msg_.stub[2], 0) + << "incorrect value for last_msg_.stub[2], expected 0, is " + << last_msg_.stub[2]; + EXPECT_EQ(last_msg_.stub[3], 0) + << "incorrect value for last_msg_.stub[3], expected 0, is " + << last_msg_.stub[3]; + EXPECT_EQ(last_msg_.stub[4], 3) + << "incorrect value for last_msg_.stub[4], expected 3, is " + << last_msg_.stub[4]; + EXPECT_EQ(last_msg_.stub[5], 0) + << "incorrect value for last_msg_.stub[5], expected 0, is " + << last_msg_.stub[5]; + EXPECT_EQ(last_msg_.stub[6], 1) + << "incorrect value for last_msg_.stub[6], expected 1, is " + << last_msg_.stub[6]; + EXPECT_EQ(last_msg_.stub[7], 2) + << "incorrect value for last_msg_.stub[7], expected 2, is " + << last_msg_.stub[7]; + EXPECT_EQ(last_msg_.stub[8], 3) + << "incorrect value for last_msg_.stub[8], expected 3, is " + << last_msg_.stub[8]; + EXPECT_EQ(last_msg_.stub[9], 4) + << "incorrect value for last_msg_.stub[9], expected 4, is " + << last_msg_.stub[9]; + EXPECT_EQ(last_msg_.stub[10], 0) + << "incorrect value for last_msg_.stub[10], expected 0, is " + << last_msg_.stub[10]; + EXPECT_EQ(last_msg_.stub[11], 5) + << "incorrect value for last_msg_.stub[11], expected 5, is " + << last_msg_.stub[11]; + EXPECT_EQ(last_msg_.stub[12], 0) + << "incorrect value for last_msg_.stub[12], expected 0, is " + << last_msg_.stub[12]; + EXPECT_EQ(last_msg_.stub[13], 6) + << "incorrect value for last_msg_.stub[13], expected 6, is " + << last_msg_.stub[13]; + EXPECT_EQ(last_msg_.stub[14], 2) + << "incorrect value for last_msg_.stub[14], expected 2, is " + << last_msg_.stub[14]; + EXPECT_EQ(last_msg_.stub[15], 10) + << "incorrect value for last_msg_.stub[15], expected 10, is " + << last_msg_.stub[15]; + EXPECT_EQ(last_msg_.stub[16], 11) + << "incorrect value for last_msg_.stub[16], expected 11, is " + << last_msg_.stub[16]; + EXPECT_EQ(last_msg_.stub[17], 15) + << "incorrect value for last_msg_.stub[17], expected 15, is " + << last_msg_.stub[17]; + EXPECT_EQ(last_msg_.stub[18], 14) + << "incorrect value for last_msg_.stub[18], expected 14, is " + << last_msg_.stub[18]; +} diff --git a/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagSatellites.cc b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagSatellites.cc new file mode 100644 index 0000000000..c12ee07271 --- /dev/null +++ b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagSatellites.cc @@ -0,0 +1,176 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagSatellites.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +#include +class Test_auto_check_sbp_integrity_MsgSsrFlagSatellites0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::MessageHandler { + public: + Test_auto_check_sbp_integrity_MsgSsrFlagSatellites0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::MessageHandler(this), + last_msg_(), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, + const sbp_msg_ssr_flag_satellites_t &msg) override { + last_msg_ = msg; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + sbp_msg_ssr_flag_satellites_t last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_auto_check_sbp_integrity_MsgSsrFlagSatellites0, Test) { + uint8_t encoded_frame[] = { + 85, 189, 11, 66, 0, 15, 180, 0, 0, 0, 3, 0, + 1, 2, 3, 4, 5, 3, 10, 11, 12, 110, 165, + }; + + sbp_msg_ssr_flag_satellites_t test_msg{}; + test_msg.n_stub = 15; + + test_msg.stub[0] = 180; + + test_msg.stub[1] = 0; + + test_msg.stub[2] = 0; + + test_msg.stub[3] = 0; + + test_msg.stub[4] = 3; + + test_msg.stub[5] = 0; + + test_msg.stub[6] = 1; + + test_msg.stub[7] = 2; + + test_msg.stub[8] = 3; + + test_msg.stub[9] = 4; + + test_msg.stub[10] = 5; + + test_msg.stub[11] = 3; + + test_msg.stub[12] = 10; + + test_msg.stub[13] = 11; + + test_msg.stub[14] = 12; + + EXPECT_EQ(send_message(66, test_msg), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_, test_msg); + EXPECT_EQ(last_msg_.n_stub, 15) + << "incorrect value for last_msg_.n_stub, expected 15, is " + << last_msg_.n_stub; + EXPECT_EQ(last_msg_.stub[0], 180) + << "incorrect value for last_msg_.stub[0], expected 180, is " + << last_msg_.stub[0]; + EXPECT_EQ(last_msg_.stub[1], 0) + << "incorrect value for last_msg_.stub[1], expected 0, is " + << last_msg_.stub[1]; + EXPECT_EQ(last_msg_.stub[2], 0) + << "incorrect value for last_msg_.stub[2], expected 0, is " + << last_msg_.stub[2]; + EXPECT_EQ(last_msg_.stub[3], 0) + << "incorrect value for last_msg_.stub[3], expected 0, is " + << last_msg_.stub[3]; + EXPECT_EQ(last_msg_.stub[4], 3) + << "incorrect value for last_msg_.stub[4], expected 3, is " + << last_msg_.stub[4]; + EXPECT_EQ(last_msg_.stub[5], 0) + << "incorrect value for last_msg_.stub[5], expected 0, is " + << last_msg_.stub[5]; + EXPECT_EQ(last_msg_.stub[6], 1) + << "incorrect value for last_msg_.stub[6], expected 1, is " + << last_msg_.stub[6]; + EXPECT_EQ(last_msg_.stub[7], 2) + << "incorrect value for last_msg_.stub[7], expected 2, is " + << last_msg_.stub[7]; + EXPECT_EQ(last_msg_.stub[8], 3) + << "incorrect value for last_msg_.stub[8], expected 3, is " + << last_msg_.stub[8]; + EXPECT_EQ(last_msg_.stub[9], 4) + << "incorrect value for last_msg_.stub[9], expected 4, is " + << last_msg_.stub[9]; + EXPECT_EQ(last_msg_.stub[10], 5) + << "incorrect value for last_msg_.stub[10], expected 5, is " + << last_msg_.stub[10]; + EXPECT_EQ(last_msg_.stub[11], 3) + << "incorrect value for last_msg_.stub[11], expected 3, is " + << last_msg_.stub[11]; + EXPECT_EQ(last_msg_.stub[12], 10) + << "incorrect value for last_msg_.stub[12], expected 10, is " + << last_msg_.stub[12]; + EXPECT_EQ(last_msg_.stub[13], 11) + << "incorrect value for last_msg_.stub[13], expected 11, is " + << last_msg_.stub[13]; + EXPECT_EQ(last_msg_.stub[14], 12) + << "incorrect value for last_msg_.stub[14], expected 12, is " + << last_msg_.stub[14]; +} diff --git a/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints.cc b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints.cc new file mode 100644 index 0000000000..068d523805 --- /dev/null +++ b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints.cc @@ -0,0 +1,207 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagTropoGridPoints.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +#include +class Test_auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::MessageHandler { + public: + Test_auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::MessageHandler(this), + last_msg_(), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg( + uint16_t sender_id, + const sbp_msg_ssr_flag_tropo_grid_points_t &msg) override { + last_msg_ = msg; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + sbp_msg_ssr_flag_tropo_grid_points_t last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints0, Test) { + uint8_t encoded_frame[] = { + 85, 195, 11, 66, 0, 21, 180, 0, 0, 0, 3, 0, 1, 2, 3, + 4, 0, 5, 0, 6, 3, 10, 0, 11, 0, 12, 0, 243, 150, + }; + + sbp_msg_ssr_flag_tropo_grid_points_t test_msg{}; + test_msg.n_stub = 21; + + test_msg.stub[0] = 180; + + test_msg.stub[1] = 0; + + test_msg.stub[2] = 0; + + test_msg.stub[3] = 0; + + test_msg.stub[4] = 3; + + test_msg.stub[5] = 0; + + test_msg.stub[6] = 1; + + test_msg.stub[7] = 2; + + test_msg.stub[8] = 3; + + test_msg.stub[9] = 4; + + test_msg.stub[10] = 0; + + test_msg.stub[11] = 5; + + test_msg.stub[12] = 0; + + test_msg.stub[13] = 6; + + test_msg.stub[14] = 3; + + test_msg.stub[15] = 10; + + test_msg.stub[16] = 0; + + test_msg.stub[17] = 11; + + test_msg.stub[18] = 0; + + test_msg.stub[19] = 12; + + test_msg.stub[20] = 0; + + EXPECT_EQ(send_message(66, test_msg), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_, test_msg); + EXPECT_EQ(last_msg_.n_stub, 21) + << "incorrect value for last_msg_.n_stub, expected 21, is " + << last_msg_.n_stub; + EXPECT_EQ(last_msg_.stub[0], 180) + << "incorrect value for last_msg_.stub[0], expected 180, is " + << last_msg_.stub[0]; + EXPECT_EQ(last_msg_.stub[1], 0) + << "incorrect value for last_msg_.stub[1], expected 0, is " + << last_msg_.stub[1]; + EXPECT_EQ(last_msg_.stub[2], 0) + << "incorrect value for last_msg_.stub[2], expected 0, is " + << last_msg_.stub[2]; + EXPECT_EQ(last_msg_.stub[3], 0) + << "incorrect value for last_msg_.stub[3], expected 0, is " + << last_msg_.stub[3]; + EXPECT_EQ(last_msg_.stub[4], 3) + << "incorrect value for last_msg_.stub[4], expected 3, is " + << last_msg_.stub[4]; + EXPECT_EQ(last_msg_.stub[5], 0) + << "incorrect value for last_msg_.stub[5], expected 0, is " + << last_msg_.stub[5]; + EXPECT_EQ(last_msg_.stub[6], 1) + << "incorrect value for last_msg_.stub[6], expected 1, is " + << last_msg_.stub[6]; + EXPECT_EQ(last_msg_.stub[7], 2) + << "incorrect value for last_msg_.stub[7], expected 2, is " + << last_msg_.stub[7]; + EXPECT_EQ(last_msg_.stub[8], 3) + << "incorrect value for last_msg_.stub[8], expected 3, is " + << last_msg_.stub[8]; + EXPECT_EQ(last_msg_.stub[9], 4) + << "incorrect value for last_msg_.stub[9], expected 4, is " + << last_msg_.stub[9]; + EXPECT_EQ(last_msg_.stub[10], 0) + << "incorrect value for last_msg_.stub[10], expected 0, is " + << last_msg_.stub[10]; + EXPECT_EQ(last_msg_.stub[11], 5) + << "incorrect value for last_msg_.stub[11], expected 5, is " + << last_msg_.stub[11]; + EXPECT_EQ(last_msg_.stub[12], 0) + << "incorrect value for last_msg_.stub[12], expected 0, is " + << last_msg_.stub[12]; + EXPECT_EQ(last_msg_.stub[13], 6) + << "incorrect value for last_msg_.stub[13], expected 6, is " + << last_msg_.stub[13]; + EXPECT_EQ(last_msg_.stub[14], 3) + << "incorrect value for last_msg_.stub[14], expected 3, is " + << last_msg_.stub[14]; + EXPECT_EQ(last_msg_.stub[15], 10) + << "incorrect value for last_msg_.stub[15], expected 10, is " + << last_msg_.stub[15]; + EXPECT_EQ(last_msg_.stub[16], 0) + << "incorrect value for last_msg_.stub[16], expected 0, is " + << last_msg_.stub[16]; + EXPECT_EQ(last_msg_.stub[17], 11) + << "incorrect value for last_msg_.stub[17], expected 11, is " + << last_msg_.stub[17]; + EXPECT_EQ(last_msg_.stub[18], 0) + << "incorrect value for last_msg_.stub[18], expected 0, is " + << last_msg_.stub[18]; + EXPECT_EQ(last_msg_.stub[19], 12) + << "incorrect value for last_msg_.stub[19], expected 12, is " + << last_msg_.stub[19]; + EXPECT_EQ(last_msg_.stub[20], 0) + << "incorrect value for last_msg_.stub[20], expected 0, is " + << last_msg_.stub[20]; +} diff --git a/c/test/cpp/auto_check_sbp_navigation_MsgGPSLeapSecond.cc b/c/test/cpp/auto_check_sbp_navigation_MsgGPSLeapSecond.cc new file mode 100644 index 0000000000..e247dbd03c --- /dev/null +++ b/c/test/cpp/auto_check_sbp_navigation_MsgGPSLeapSecond.cc @@ -0,0 +1,170 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSLeapSecond.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +#include +class Test_auto_check_sbp_navigation_MsgGPSLeapSecond0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::MessageHandler { + public: + Test_auto_check_sbp_navigation_MsgGPSLeapSecond0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::MessageHandler(this), + last_msg_(), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, + const sbp_msg_gps_leap_second_t &msg) override { + last_msg_ = msg; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + sbp_msg_gps_leap_second_t last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_auto_check_sbp_navigation_MsgGPSLeapSecond0, Test) { + uint8_t encoded_frame[] = { + 85, 58, 2, 66, 0, 14, 1, 0, 2, 0, 3, 4, 5, 0, 6, 0, 7, 0, 8, 9, 50, 232, + }; + + sbp_msg_gps_leap_second_t test_msg{}; + test_msg.n_stub = 14; + + test_msg.stub[0] = 1; + + test_msg.stub[1] = 0; + + test_msg.stub[2] = 2; + + test_msg.stub[3] = 0; + + test_msg.stub[4] = 3; + + test_msg.stub[5] = 4; + + test_msg.stub[6] = 5; + + test_msg.stub[7] = 0; + + test_msg.stub[8] = 6; + + test_msg.stub[9] = 0; + + test_msg.stub[10] = 7; + + test_msg.stub[11] = 0; + + test_msg.stub[12] = 8; + + test_msg.stub[13] = 9; + + EXPECT_EQ(send_message(66, test_msg), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_, test_msg); + EXPECT_EQ(last_msg_.n_stub, 14) + << "incorrect value for last_msg_.n_stub, expected 14, is " + << last_msg_.n_stub; + EXPECT_EQ(last_msg_.stub[0], 1) + << "incorrect value for last_msg_.stub[0], expected 1, is " + << last_msg_.stub[0]; + EXPECT_EQ(last_msg_.stub[1], 0) + << "incorrect value for last_msg_.stub[1], expected 0, is " + << last_msg_.stub[1]; + EXPECT_EQ(last_msg_.stub[2], 2) + << "incorrect value for last_msg_.stub[2], expected 2, is " + << last_msg_.stub[2]; + EXPECT_EQ(last_msg_.stub[3], 0) + << "incorrect value for last_msg_.stub[3], expected 0, is " + << last_msg_.stub[3]; + EXPECT_EQ(last_msg_.stub[4], 3) + << "incorrect value for last_msg_.stub[4], expected 3, is " + << last_msg_.stub[4]; + EXPECT_EQ(last_msg_.stub[5], 4) + << "incorrect value for last_msg_.stub[5], expected 4, is " + << last_msg_.stub[5]; + EXPECT_EQ(last_msg_.stub[6], 5) + << "incorrect value for last_msg_.stub[6], expected 5, is " + << last_msg_.stub[6]; + EXPECT_EQ(last_msg_.stub[7], 0) + << "incorrect value for last_msg_.stub[7], expected 0, is " + << last_msg_.stub[7]; + EXPECT_EQ(last_msg_.stub[8], 6) + << "incorrect value for last_msg_.stub[8], expected 6, is " + << last_msg_.stub[8]; + EXPECT_EQ(last_msg_.stub[9], 0) + << "incorrect value for last_msg_.stub[9], expected 0, is " + << last_msg_.stub[9]; + EXPECT_EQ(last_msg_.stub[10], 7) + << "incorrect value for last_msg_.stub[10], expected 7, is " + << last_msg_.stub[10]; + EXPECT_EQ(last_msg_.stub[11], 0) + << "incorrect value for last_msg_.stub[11], expected 0, is " + << last_msg_.stub[11]; + EXPECT_EQ(last_msg_.stub[12], 8) + << "incorrect value for last_msg_.stub[12], expected 8, is " + << last_msg_.stub[12]; + EXPECT_EQ(last_msg_.stub[13], 9) + << "incorrect value for last_msg_.stub[13], expected 9, is " + << last_msg_.stub[13]; +} diff --git a/c/test/cpp/auto_check_sbp_navigation_MsgItrf.cc b/c/test/cpp/auto_check_sbp_navigation_MsgItrf.cc new file mode 100644 index 0000000000..ede485d74d --- /dev/null +++ b/c/test/cpp/auto_check_sbp_navigation_MsgItrf.cc @@ -0,0 +1,726 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml by generate.py. Do +// not modify by hand! + +#include +#include +#include +#include +#include +class Test_auto_check_sbp_navigation_MsgItrf0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::MessageHandler { + public: + Test_auto_check_sbp_navigation_MsgItrf0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::MessageHandler(this), + last_msg_(), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, const sbp_msg_itrf_t &msg) override { + last_msg_ = msg; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + sbp_msg_itrf_t last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_auto_check_sbp_navigation_MsgItrf0, Test) { + uint8_t encoded_frame[] = { + 85, 68, 2, 66, 0, 124, 1, 2, 102, 111, 111, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 98, 97, 114, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 5, 0, 6, 0, 7, 0, 0, 0, 8, 0, 0, 0, 9, + 0, 0, 0, 10, 0, 0, 0, 11, 0, 0, 0, 12, 0, 0, 0, 13, 0, + 0, 0, 14, 0, 0, 0, 15, 0, 0, 0, 16, 0, 0, 0, 17, 0, 0, + 0, 18, 0, 0, 0, 19, 0, 0, 0, 20, 0, 66, 126, + }; + + sbp_msg_itrf_t test_msg{}; + test_msg.n_stub = 124; + + test_msg.stub[0] = 1; + + test_msg.stub[1] = 2; + + test_msg.stub[2] = 102; + + test_msg.stub[3] = 111; + + test_msg.stub[4] = 111; + + test_msg.stub[5] = 0; + + test_msg.stub[6] = 0; + + test_msg.stub[7] = 0; + + test_msg.stub[8] = 0; + + test_msg.stub[9] = 0; + + test_msg.stub[10] = 0; + + test_msg.stub[11] = 0; + + test_msg.stub[12] = 0; + + test_msg.stub[13] = 0; + + test_msg.stub[14] = 0; + + test_msg.stub[15] = 0; + + test_msg.stub[16] = 0; + + test_msg.stub[17] = 0; + + test_msg.stub[18] = 0; + + test_msg.stub[19] = 0; + + test_msg.stub[20] = 0; + + test_msg.stub[21] = 0; + + test_msg.stub[22] = 0; + + test_msg.stub[23] = 0; + + test_msg.stub[24] = 0; + + test_msg.stub[25] = 0; + + test_msg.stub[26] = 0; + + test_msg.stub[27] = 0; + + test_msg.stub[28] = 0; + + test_msg.stub[29] = 0; + + test_msg.stub[30] = 0; + + test_msg.stub[31] = 0; + + test_msg.stub[32] = 0; + + test_msg.stub[33] = 3; + + test_msg.stub[34] = 98; + + test_msg.stub[35] = 97; + + test_msg.stub[36] = 114; + + test_msg.stub[37] = 0; + + test_msg.stub[38] = 0; + + test_msg.stub[39] = 0; + + test_msg.stub[40] = 0; + + test_msg.stub[41] = 0; + + test_msg.stub[42] = 0; + + test_msg.stub[43] = 0; + + test_msg.stub[44] = 0; + + test_msg.stub[45] = 0; + + test_msg.stub[46] = 0; + + test_msg.stub[47] = 0; + + test_msg.stub[48] = 0; + + test_msg.stub[49] = 0; + + test_msg.stub[50] = 0; + + test_msg.stub[51] = 0; + + test_msg.stub[52] = 0; + + test_msg.stub[53] = 0; + + test_msg.stub[54] = 0; + + test_msg.stub[55] = 0; + + test_msg.stub[56] = 0; + + test_msg.stub[57] = 0; + + test_msg.stub[58] = 0; + + test_msg.stub[59] = 0; + + test_msg.stub[60] = 0; + + test_msg.stub[61] = 0; + + test_msg.stub[62] = 0; + + test_msg.stub[63] = 0; + + test_msg.stub[64] = 0; + + test_msg.stub[65] = 4; + + test_msg.stub[66] = 5; + + test_msg.stub[67] = 0; + + test_msg.stub[68] = 6; + + test_msg.stub[69] = 0; + + test_msg.stub[70] = 7; + + test_msg.stub[71] = 0; + + test_msg.stub[72] = 0; + + test_msg.stub[73] = 0; + + test_msg.stub[74] = 8; + + test_msg.stub[75] = 0; + + test_msg.stub[76] = 0; + + test_msg.stub[77] = 0; + + test_msg.stub[78] = 9; + + test_msg.stub[79] = 0; + + test_msg.stub[80] = 0; + + test_msg.stub[81] = 0; + + test_msg.stub[82] = 10; + + test_msg.stub[83] = 0; + + test_msg.stub[84] = 0; + + test_msg.stub[85] = 0; + + test_msg.stub[86] = 11; + + test_msg.stub[87] = 0; + + test_msg.stub[88] = 0; + + test_msg.stub[89] = 0; + + test_msg.stub[90] = 12; + + test_msg.stub[91] = 0; + + test_msg.stub[92] = 0; + + test_msg.stub[93] = 0; + + test_msg.stub[94] = 13; + + test_msg.stub[95] = 0; + + test_msg.stub[96] = 0; + + test_msg.stub[97] = 0; + + test_msg.stub[98] = 14; + + test_msg.stub[99] = 0; + + test_msg.stub[100] = 0; + + test_msg.stub[101] = 0; + + test_msg.stub[102] = 15; + + test_msg.stub[103] = 0; + + test_msg.stub[104] = 0; + + test_msg.stub[105] = 0; + + test_msg.stub[106] = 16; + + test_msg.stub[107] = 0; + + test_msg.stub[108] = 0; + + test_msg.stub[109] = 0; + + test_msg.stub[110] = 17; + + test_msg.stub[111] = 0; + + test_msg.stub[112] = 0; + + test_msg.stub[113] = 0; + + test_msg.stub[114] = 18; + + test_msg.stub[115] = 0; + + test_msg.stub[116] = 0; + + test_msg.stub[117] = 0; + + test_msg.stub[118] = 19; + + test_msg.stub[119] = 0; + + test_msg.stub[120] = 0; + + test_msg.stub[121] = 0; + + test_msg.stub[122] = 20; + + test_msg.stub[123] = 0; + + EXPECT_EQ(send_message(66, test_msg), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_, test_msg); + EXPECT_EQ(last_msg_.n_stub, 124) + << "incorrect value for last_msg_.n_stub, expected 124, is " + << last_msg_.n_stub; + EXPECT_EQ(last_msg_.stub[0], 1) + << "incorrect value for last_msg_.stub[0], expected 1, is " + << last_msg_.stub[0]; + EXPECT_EQ(last_msg_.stub[1], 2) + << "incorrect value for last_msg_.stub[1], expected 2, is " + << last_msg_.stub[1]; + EXPECT_EQ(last_msg_.stub[2], 102) + << "incorrect value for last_msg_.stub[2], expected 102, is " + << last_msg_.stub[2]; + EXPECT_EQ(last_msg_.stub[3], 111) + << "incorrect value for last_msg_.stub[3], expected 111, is " + << last_msg_.stub[3]; + EXPECT_EQ(last_msg_.stub[4], 111) + << "incorrect value for last_msg_.stub[4], expected 111, is " + << last_msg_.stub[4]; + EXPECT_EQ(last_msg_.stub[5], 0) + << "incorrect value for last_msg_.stub[5], expected 0, is " + << last_msg_.stub[5]; + EXPECT_EQ(last_msg_.stub[6], 0) + << "incorrect value for last_msg_.stub[6], expected 0, is " + << last_msg_.stub[6]; + EXPECT_EQ(last_msg_.stub[7], 0) + << "incorrect value for last_msg_.stub[7], expected 0, is " + << last_msg_.stub[7]; + EXPECT_EQ(last_msg_.stub[8], 0) + << "incorrect value for last_msg_.stub[8], expected 0, is " + << last_msg_.stub[8]; + EXPECT_EQ(last_msg_.stub[9], 0) + << "incorrect value for last_msg_.stub[9], expected 0, is " + << last_msg_.stub[9]; + EXPECT_EQ(last_msg_.stub[10], 0) + << "incorrect value for last_msg_.stub[10], expected 0, is " + << last_msg_.stub[10]; + EXPECT_EQ(last_msg_.stub[11], 0) + << "incorrect value for last_msg_.stub[11], expected 0, is " + << last_msg_.stub[11]; + EXPECT_EQ(last_msg_.stub[12], 0) + << "incorrect value for last_msg_.stub[12], expected 0, is " + << last_msg_.stub[12]; + EXPECT_EQ(last_msg_.stub[13], 0) + << "incorrect value for last_msg_.stub[13], expected 0, is " + << last_msg_.stub[13]; + EXPECT_EQ(last_msg_.stub[14], 0) + << "incorrect value for last_msg_.stub[14], expected 0, is " + << last_msg_.stub[14]; + EXPECT_EQ(last_msg_.stub[15], 0) + << "incorrect value for last_msg_.stub[15], expected 0, is " + << last_msg_.stub[15]; + EXPECT_EQ(last_msg_.stub[16], 0) + << "incorrect value for last_msg_.stub[16], expected 0, is " + << last_msg_.stub[16]; + EXPECT_EQ(last_msg_.stub[17], 0) + << "incorrect value for last_msg_.stub[17], expected 0, is " + << last_msg_.stub[17]; + EXPECT_EQ(last_msg_.stub[18], 0) + << "incorrect value for last_msg_.stub[18], expected 0, is " + << last_msg_.stub[18]; + EXPECT_EQ(last_msg_.stub[19], 0) + << "incorrect value for last_msg_.stub[19], expected 0, is " + << last_msg_.stub[19]; + EXPECT_EQ(last_msg_.stub[20], 0) + << "incorrect value for last_msg_.stub[20], expected 0, is " + << last_msg_.stub[20]; + EXPECT_EQ(last_msg_.stub[21], 0) + << "incorrect value for last_msg_.stub[21], expected 0, is " + << last_msg_.stub[21]; + EXPECT_EQ(last_msg_.stub[22], 0) + << "incorrect value for last_msg_.stub[22], expected 0, is " + << last_msg_.stub[22]; + EXPECT_EQ(last_msg_.stub[23], 0) + << "incorrect value for last_msg_.stub[23], expected 0, is " + << last_msg_.stub[23]; + EXPECT_EQ(last_msg_.stub[24], 0) + << "incorrect value for last_msg_.stub[24], expected 0, is " + << last_msg_.stub[24]; + EXPECT_EQ(last_msg_.stub[25], 0) + << "incorrect value for last_msg_.stub[25], expected 0, is " + << last_msg_.stub[25]; + EXPECT_EQ(last_msg_.stub[26], 0) + << "incorrect value for last_msg_.stub[26], expected 0, is " + << last_msg_.stub[26]; + EXPECT_EQ(last_msg_.stub[27], 0) + << "incorrect value for last_msg_.stub[27], expected 0, is " + << last_msg_.stub[27]; + EXPECT_EQ(last_msg_.stub[28], 0) + << "incorrect value for last_msg_.stub[28], expected 0, is " + << last_msg_.stub[28]; + EXPECT_EQ(last_msg_.stub[29], 0) + << "incorrect value for last_msg_.stub[29], expected 0, is " + << last_msg_.stub[29]; + EXPECT_EQ(last_msg_.stub[30], 0) + << "incorrect value for last_msg_.stub[30], expected 0, is " + << last_msg_.stub[30]; + EXPECT_EQ(last_msg_.stub[31], 0) + << "incorrect value for last_msg_.stub[31], expected 0, is " + << last_msg_.stub[31]; + EXPECT_EQ(last_msg_.stub[32], 0) + << "incorrect value for last_msg_.stub[32], expected 0, is " + << last_msg_.stub[32]; + EXPECT_EQ(last_msg_.stub[33], 3) + << "incorrect value for last_msg_.stub[33], expected 3, is " + << last_msg_.stub[33]; + EXPECT_EQ(last_msg_.stub[34], 98) + << "incorrect value for last_msg_.stub[34], expected 98, is " + << last_msg_.stub[34]; + EXPECT_EQ(last_msg_.stub[35], 97) + << "incorrect value for last_msg_.stub[35], expected 97, is " + << last_msg_.stub[35]; + EXPECT_EQ(last_msg_.stub[36], 114) + << "incorrect value for last_msg_.stub[36], expected 114, is " + << last_msg_.stub[36]; + EXPECT_EQ(last_msg_.stub[37], 0) + << "incorrect value for last_msg_.stub[37], expected 0, is " + << last_msg_.stub[37]; + EXPECT_EQ(last_msg_.stub[38], 0) + << "incorrect value for last_msg_.stub[38], expected 0, is " + << last_msg_.stub[38]; + EXPECT_EQ(last_msg_.stub[39], 0) + << "incorrect value for last_msg_.stub[39], expected 0, is " + << last_msg_.stub[39]; + EXPECT_EQ(last_msg_.stub[40], 0) + << "incorrect value for last_msg_.stub[40], expected 0, is " + << last_msg_.stub[40]; + EXPECT_EQ(last_msg_.stub[41], 0) + << "incorrect value for last_msg_.stub[41], expected 0, is " + << last_msg_.stub[41]; + EXPECT_EQ(last_msg_.stub[42], 0) + << "incorrect value for last_msg_.stub[42], expected 0, is " + << last_msg_.stub[42]; + EXPECT_EQ(last_msg_.stub[43], 0) + << "incorrect value for last_msg_.stub[43], expected 0, is " + << last_msg_.stub[43]; + EXPECT_EQ(last_msg_.stub[44], 0) + << "incorrect value for last_msg_.stub[44], expected 0, is " + << last_msg_.stub[44]; + EXPECT_EQ(last_msg_.stub[45], 0) + << "incorrect value for last_msg_.stub[45], expected 0, is " + << last_msg_.stub[45]; + EXPECT_EQ(last_msg_.stub[46], 0) + << "incorrect value for last_msg_.stub[46], expected 0, is " + << last_msg_.stub[46]; + EXPECT_EQ(last_msg_.stub[47], 0) + << "incorrect value for last_msg_.stub[47], expected 0, is " + << last_msg_.stub[47]; + EXPECT_EQ(last_msg_.stub[48], 0) + << "incorrect value for last_msg_.stub[48], expected 0, is " + << last_msg_.stub[48]; + EXPECT_EQ(last_msg_.stub[49], 0) + << "incorrect value for last_msg_.stub[49], expected 0, is " + << last_msg_.stub[49]; + EXPECT_EQ(last_msg_.stub[50], 0) + << "incorrect value for last_msg_.stub[50], expected 0, is " + << last_msg_.stub[50]; + EXPECT_EQ(last_msg_.stub[51], 0) + << "incorrect value for last_msg_.stub[51], expected 0, is " + << last_msg_.stub[51]; + EXPECT_EQ(last_msg_.stub[52], 0) + << "incorrect value for last_msg_.stub[52], expected 0, is " + << last_msg_.stub[52]; + EXPECT_EQ(last_msg_.stub[53], 0) + << "incorrect value for last_msg_.stub[53], expected 0, is " + << last_msg_.stub[53]; + EXPECT_EQ(last_msg_.stub[54], 0) + << "incorrect value for last_msg_.stub[54], expected 0, is " + << last_msg_.stub[54]; + EXPECT_EQ(last_msg_.stub[55], 0) + << "incorrect value for last_msg_.stub[55], expected 0, is " + << last_msg_.stub[55]; + EXPECT_EQ(last_msg_.stub[56], 0) + << "incorrect value for last_msg_.stub[56], expected 0, is " + << last_msg_.stub[56]; + EXPECT_EQ(last_msg_.stub[57], 0) + << "incorrect value for last_msg_.stub[57], expected 0, is " + << last_msg_.stub[57]; + EXPECT_EQ(last_msg_.stub[58], 0) + << "incorrect value for last_msg_.stub[58], expected 0, is " + << last_msg_.stub[58]; + EXPECT_EQ(last_msg_.stub[59], 0) + << "incorrect value for last_msg_.stub[59], expected 0, is " + << last_msg_.stub[59]; + EXPECT_EQ(last_msg_.stub[60], 0) + << "incorrect value for last_msg_.stub[60], expected 0, is " + << last_msg_.stub[60]; + EXPECT_EQ(last_msg_.stub[61], 0) + << "incorrect value for last_msg_.stub[61], expected 0, is " + << last_msg_.stub[61]; + EXPECT_EQ(last_msg_.stub[62], 0) + << "incorrect value for last_msg_.stub[62], expected 0, is " + << last_msg_.stub[62]; + EXPECT_EQ(last_msg_.stub[63], 0) + << "incorrect value for last_msg_.stub[63], expected 0, is " + << last_msg_.stub[63]; + EXPECT_EQ(last_msg_.stub[64], 0) + << "incorrect value for last_msg_.stub[64], expected 0, is " + << last_msg_.stub[64]; + EXPECT_EQ(last_msg_.stub[65], 4) + << "incorrect value for last_msg_.stub[65], expected 4, is " + << last_msg_.stub[65]; + EXPECT_EQ(last_msg_.stub[66], 5) + << "incorrect value for last_msg_.stub[66], expected 5, is " + << last_msg_.stub[66]; + EXPECT_EQ(last_msg_.stub[67], 0) + << "incorrect value for last_msg_.stub[67], expected 0, is " + << last_msg_.stub[67]; + EXPECT_EQ(last_msg_.stub[68], 6) + << "incorrect value for last_msg_.stub[68], expected 6, is " + << last_msg_.stub[68]; + EXPECT_EQ(last_msg_.stub[69], 0) + << "incorrect value for last_msg_.stub[69], expected 0, is " + << last_msg_.stub[69]; + EXPECT_EQ(last_msg_.stub[70], 7) + << "incorrect value for last_msg_.stub[70], expected 7, is " + << last_msg_.stub[70]; + EXPECT_EQ(last_msg_.stub[71], 0) + << "incorrect value for last_msg_.stub[71], expected 0, is " + << last_msg_.stub[71]; + EXPECT_EQ(last_msg_.stub[72], 0) + << "incorrect value for last_msg_.stub[72], expected 0, is " + << last_msg_.stub[72]; + EXPECT_EQ(last_msg_.stub[73], 0) + << "incorrect value for last_msg_.stub[73], expected 0, is " + << last_msg_.stub[73]; + EXPECT_EQ(last_msg_.stub[74], 8) + << "incorrect value for last_msg_.stub[74], expected 8, is " + << last_msg_.stub[74]; + EXPECT_EQ(last_msg_.stub[75], 0) + << "incorrect value for last_msg_.stub[75], expected 0, is " + << last_msg_.stub[75]; + EXPECT_EQ(last_msg_.stub[76], 0) + << "incorrect value for last_msg_.stub[76], expected 0, is " + << last_msg_.stub[76]; + EXPECT_EQ(last_msg_.stub[77], 0) + << "incorrect value for last_msg_.stub[77], expected 0, is " + << last_msg_.stub[77]; + EXPECT_EQ(last_msg_.stub[78], 9) + << "incorrect value for last_msg_.stub[78], expected 9, is " + << last_msg_.stub[78]; + EXPECT_EQ(last_msg_.stub[79], 0) + << "incorrect value for last_msg_.stub[79], expected 0, is " + << last_msg_.stub[79]; + EXPECT_EQ(last_msg_.stub[80], 0) + << "incorrect value for last_msg_.stub[80], expected 0, is " + << last_msg_.stub[80]; + EXPECT_EQ(last_msg_.stub[81], 0) + << "incorrect value for last_msg_.stub[81], expected 0, is " + << last_msg_.stub[81]; + EXPECT_EQ(last_msg_.stub[82], 10) + << "incorrect value for last_msg_.stub[82], expected 10, is " + << last_msg_.stub[82]; + EXPECT_EQ(last_msg_.stub[83], 0) + << "incorrect value for last_msg_.stub[83], expected 0, is " + << last_msg_.stub[83]; + EXPECT_EQ(last_msg_.stub[84], 0) + << "incorrect value for last_msg_.stub[84], expected 0, is " + << last_msg_.stub[84]; + EXPECT_EQ(last_msg_.stub[85], 0) + << "incorrect value for last_msg_.stub[85], expected 0, is " + << last_msg_.stub[85]; + EXPECT_EQ(last_msg_.stub[86], 11) + << "incorrect value for last_msg_.stub[86], expected 11, is " + << last_msg_.stub[86]; + EXPECT_EQ(last_msg_.stub[87], 0) + << "incorrect value for last_msg_.stub[87], expected 0, is " + << last_msg_.stub[87]; + EXPECT_EQ(last_msg_.stub[88], 0) + << "incorrect value for last_msg_.stub[88], expected 0, is " + << last_msg_.stub[88]; + EXPECT_EQ(last_msg_.stub[89], 0) + << "incorrect value for last_msg_.stub[89], expected 0, is " + << last_msg_.stub[89]; + EXPECT_EQ(last_msg_.stub[90], 12) + << "incorrect value for last_msg_.stub[90], expected 12, is " + << last_msg_.stub[90]; + EXPECT_EQ(last_msg_.stub[91], 0) + << "incorrect value for last_msg_.stub[91], expected 0, is " + << last_msg_.stub[91]; + EXPECT_EQ(last_msg_.stub[92], 0) + << "incorrect value for last_msg_.stub[92], expected 0, is " + << last_msg_.stub[92]; + EXPECT_EQ(last_msg_.stub[93], 0) + << "incorrect value for last_msg_.stub[93], expected 0, is " + << last_msg_.stub[93]; + EXPECT_EQ(last_msg_.stub[94], 13) + << "incorrect value for last_msg_.stub[94], expected 13, is " + << last_msg_.stub[94]; + EXPECT_EQ(last_msg_.stub[95], 0) + << "incorrect value for last_msg_.stub[95], expected 0, is " + << last_msg_.stub[95]; + EXPECT_EQ(last_msg_.stub[96], 0) + << "incorrect value for last_msg_.stub[96], expected 0, is " + << last_msg_.stub[96]; + EXPECT_EQ(last_msg_.stub[97], 0) + << "incorrect value for last_msg_.stub[97], expected 0, is " + << last_msg_.stub[97]; + EXPECT_EQ(last_msg_.stub[98], 14) + << "incorrect value for last_msg_.stub[98], expected 14, is " + << last_msg_.stub[98]; + EXPECT_EQ(last_msg_.stub[99], 0) + << "incorrect value for last_msg_.stub[99], expected 0, is " + << last_msg_.stub[99]; + EXPECT_EQ(last_msg_.stub[100], 0) + << "incorrect value for last_msg_.stub[100], expected 0, is " + << last_msg_.stub[100]; + EXPECT_EQ(last_msg_.stub[101], 0) + << "incorrect value for last_msg_.stub[101], expected 0, is " + << last_msg_.stub[101]; + EXPECT_EQ(last_msg_.stub[102], 15) + << "incorrect value for last_msg_.stub[102], expected 15, is " + << last_msg_.stub[102]; + EXPECT_EQ(last_msg_.stub[103], 0) + << "incorrect value for last_msg_.stub[103], expected 0, is " + << last_msg_.stub[103]; + EXPECT_EQ(last_msg_.stub[104], 0) + << "incorrect value for last_msg_.stub[104], expected 0, is " + << last_msg_.stub[104]; + EXPECT_EQ(last_msg_.stub[105], 0) + << "incorrect value for last_msg_.stub[105], expected 0, is " + << last_msg_.stub[105]; + EXPECT_EQ(last_msg_.stub[106], 16) + << "incorrect value for last_msg_.stub[106], expected 16, is " + << last_msg_.stub[106]; + EXPECT_EQ(last_msg_.stub[107], 0) + << "incorrect value for last_msg_.stub[107], expected 0, is " + << last_msg_.stub[107]; + EXPECT_EQ(last_msg_.stub[108], 0) + << "incorrect value for last_msg_.stub[108], expected 0, is " + << last_msg_.stub[108]; + EXPECT_EQ(last_msg_.stub[109], 0) + << "incorrect value for last_msg_.stub[109], expected 0, is " + << last_msg_.stub[109]; + EXPECT_EQ(last_msg_.stub[110], 17) + << "incorrect value for last_msg_.stub[110], expected 17, is " + << last_msg_.stub[110]; + EXPECT_EQ(last_msg_.stub[111], 0) + << "incorrect value for last_msg_.stub[111], expected 0, is " + << last_msg_.stub[111]; + EXPECT_EQ(last_msg_.stub[112], 0) + << "incorrect value for last_msg_.stub[112], expected 0, is " + << last_msg_.stub[112]; + EXPECT_EQ(last_msg_.stub[113], 0) + << "incorrect value for last_msg_.stub[113], expected 0, is " + << last_msg_.stub[113]; + EXPECT_EQ(last_msg_.stub[114], 18) + << "incorrect value for last_msg_.stub[114], expected 18, is " + << last_msg_.stub[114]; + EXPECT_EQ(last_msg_.stub[115], 0) + << "incorrect value for last_msg_.stub[115], expected 0, is " + << last_msg_.stub[115]; + EXPECT_EQ(last_msg_.stub[116], 0) + << "incorrect value for last_msg_.stub[116], expected 0, is " + << last_msg_.stub[116]; + EXPECT_EQ(last_msg_.stub[117], 0) + << "incorrect value for last_msg_.stub[117], expected 0, is " + << last_msg_.stub[117]; + EXPECT_EQ(last_msg_.stub[118], 19) + << "incorrect value for last_msg_.stub[118], expected 19, is " + << last_msg_.stub[118]; + EXPECT_EQ(last_msg_.stub[119], 0) + << "incorrect value for last_msg_.stub[119], expected 0, is " + << last_msg_.stub[119]; + EXPECT_EQ(last_msg_.stub[120], 0) + << "incorrect value for last_msg_.stub[120], expected 0, is " + << last_msg_.stub[120]; + EXPECT_EQ(last_msg_.stub[121], 0) + << "incorrect value for last_msg_.stub[121], expected 0, is " + << last_msg_.stub[121]; + EXPECT_EQ(last_msg_.stub[122], 20) + << "incorrect value for last_msg_.stub[122], expected 20, is " + << last_msg_.stub[122]; + EXPECT_EQ(last_msg_.stub[123], 0) + << "incorrect value for last_msg_.stub[123], expected 0, is " + << last_msg_.stub[123]; +} diff --git a/c/test/cpp/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds.cc b/c/test/cpp/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds.cc new file mode 100644 index 0000000000..b9c5abf982 --- /dev/null +++ b/c/test/cpp/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds.cc @@ -0,0 +1,257 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrCodePhaseBiasesBounds.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +#include +class Test_auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::MessageHandler { + public: + Test_auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::MessageHandler(this), + last_msg_(), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg( + uint16_t sender_id, + const sbp_msg_ssr_code_phase_biases_bounds_t &msg) override { + last_msg_ = msg; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + sbp_msg_ssr_code_phase_biases_bounds_t last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds0, Test) { + uint8_t encoded_frame[] = { + 85, 236, 5, 66, 0, 31, 180, 0, 0, 0, 3, 0, 1, 2, 1, 14, 15, 1, 3, 0, + 3, 39, 1, 39, 1, 1, 3, 39, 1, 39, 1, 1, 1, 39, 1, 39, 1, 23, 113, + }; + + sbp_msg_ssr_code_phase_biases_bounds_t test_msg{}; + test_msg.n_stub = 31; + + test_msg.stub[0] = 180; + + test_msg.stub[1] = 0; + + test_msg.stub[2] = 0; + + test_msg.stub[3] = 0; + + test_msg.stub[4] = 3; + + test_msg.stub[5] = 0; + + test_msg.stub[6] = 1; + + test_msg.stub[7] = 2; + + test_msg.stub[8] = 1; + + test_msg.stub[9] = 14; + + test_msg.stub[10] = 15; + + test_msg.stub[11] = 1; + + test_msg.stub[12] = 3; + + test_msg.stub[13] = 0; + + test_msg.stub[14] = 3; + + test_msg.stub[15] = 39; + + test_msg.stub[16] = 1; + + test_msg.stub[17] = 39; + + test_msg.stub[18] = 1; + + test_msg.stub[19] = 1; + + test_msg.stub[20] = 3; + + test_msg.stub[21] = 39; + + test_msg.stub[22] = 1; + + test_msg.stub[23] = 39; + + test_msg.stub[24] = 1; + + test_msg.stub[25] = 1; + + test_msg.stub[26] = 1; + + test_msg.stub[27] = 39; + + test_msg.stub[28] = 1; + + test_msg.stub[29] = 39; + + test_msg.stub[30] = 1; + + EXPECT_EQ(send_message(66, test_msg), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_, test_msg); + EXPECT_EQ(last_msg_.n_stub, 31) + << "incorrect value for last_msg_.n_stub, expected 31, is " + << last_msg_.n_stub; + EXPECT_EQ(last_msg_.stub[0], 180) + << "incorrect value for last_msg_.stub[0], expected 180, is " + << last_msg_.stub[0]; + EXPECT_EQ(last_msg_.stub[1], 0) + << "incorrect value for last_msg_.stub[1], expected 0, is " + << last_msg_.stub[1]; + EXPECT_EQ(last_msg_.stub[2], 0) + << "incorrect value for last_msg_.stub[2], expected 0, is " + << last_msg_.stub[2]; + EXPECT_EQ(last_msg_.stub[3], 0) + << "incorrect value for last_msg_.stub[3], expected 0, is " + << last_msg_.stub[3]; + EXPECT_EQ(last_msg_.stub[4], 3) + << "incorrect value for last_msg_.stub[4], expected 3, is " + << last_msg_.stub[4]; + EXPECT_EQ(last_msg_.stub[5], 0) + << "incorrect value for last_msg_.stub[5], expected 0, is " + << last_msg_.stub[5]; + EXPECT_EQ(last_msg_.stub[6], 1) + << "incorrect value for last_msg_.stub[6], expected 1, is " + << last_msg_.stub[6]; + EXPECT_EQ(last_msg_.stub[7], 2) + << "incorrect value for last_msg_.stub[7], expected 2, is " + << last_msg_.stub[7]; + EXPECT_EQ(last_msg_.stub[8], 1) + << "incorrect value for last_msg_.stub[8], expected 1, is " + << last_msg_.stub[8]; + EXPECT_EQ(last_msg_.stub[9], 14) + << "incorrect value for last_msg_.stub[9], expected 14, is " + << last_msg_.stub[9]; + EXPECT_EQ(last_msg_.stub[10], 15) + << "incorrect value for last_msg_.stub[10], expected 15, is " + << last_msg_.stub[10]; + EXPECT_EQ(last_msg_.stub[11], 1) + << "incorrect value for last_msg_.stub[11], expected 1, is " + << last_msg_.stub[11]; + EXPECT_EQ(last_msg_.stub[12], 3) + << "incorrect value for last_msg_.stub[12], expected 3, is " + << last_msg_.stub[12]; + EXPECT_EQ(last_msg_.stub[13], 0) + << "incorrect value for last_msg_.stub[13], expected 0, is " + << last_msg_.stub[13]; + EXPECT_EQ(last_msg_.stub[14], 3) + << "incorrect value for last_msg_.stub[14], expected 3, is " + << last_msg_.stub[14]; + EXPECT_EQ(last_msg_.stub[15], 39) + << "incorrect value for last_msg_.stub[15], expected 39, is " + << last_msg_.stub[15]; + EXPECT_EQ(last_msg_.stub[16], 1) + << "incorrect value for last_msg_.stub[16], expected 1, is " + << last_msg_.stub[16]; + EXPECT_EQ(last_msg_.stub[17], 39) + << "incorrect value for last_msg_.stub[17], expected 39, is " + << last_msg_.stub[17]; + EXPECT_EQ(last_msg_.stub[18], 1) + << "incorrect value for last_msg_.stub[18], expected 1, is " + << last_msg_.stub[18]; + EXPECT_EQ(last_msg_.stub[19], 1) + << "incorrect value for last_msg_.stub[19], expected 1, is " + << last_msg_.stub[19]; + EXPECT_EQ(last_msg_.stub[20], 3) + << "incorrect value for last_msg_.stub[20], expected 3, is " + << last_msg_.stub[20]; + EXPECT_EQ(last_msg_.stub[21], 39) + << "incorrect value for last_msg_.stub[21], expected 39, is " + << last_msg_.stub[21]; + EXPECT_EQ(last_msg_.stub[22], 1) + << "incorrect value for last_msg_.stub[22], expected 1, is " + << last_msg_.stub[22]; + EXPECT_EQ(last_msg_.stub[23], 39) + << "incorrect value for last_msg_.stub[23], expected 39, is " + << last_msg_.stub[23]; + EXPECT_EQ(last_msg_.stub[24], 1) + << "incorrect value for last_msg_.stub[24], expected 1, is " + << last_msg_.stub[24]; + EXPECT_EQ(last_msg_.stub[25], 1) + << "incorrect value for last_msg_.stub[25], expected 1, is " + << last_msg_.stub[25]; + EXPECT_EQ(last_msg_.stub[26], 1) + << "incorrect value for last_msg_.stub[26], expected 1, is " + << last_msg_.stub[26]; + EXPECT_EQ(last_msg_.stub[27], 39) + << "incorrect value for last_msg_.stub[27], expected 39, is " + << last_msg_.stub[27]; + EXPECT_EQ(last_msg_.stub[28], 1) + << "incorrect value for last_msg_.stub[28], expected 1, is " + << last_msg_.stub[28]; + EXPECT_EQ(last_msg_.stub[29], 39) + << "incorrect value for last_msg_.stub[29], expected 39, is " + << last_msg_.stub[29]; + EXPECT_EQ(last_msg_.stub[30], 1) + << "incorrect value for last_msg_.stub[30], expected 1, is " + << last_msg_.stub[30]; +} diff --git a/c/test/cpp/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds.cc b/c/test/cpp/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds.cc new file mode 100644 index 0000000000..e63007acea --- /dev/null +++ b/c/test/cpp/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds.cc @@ -0,0 +1,319 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrectionBounds.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +#include +class Test_auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::MessageHandler { + public: + Test_auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::MessageHandler(this), + last_msg_(), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg( + uint16_t sender_id, + const sbp_msg_ssr_gridded_correction_bounds_t &msg) override { + last_msg_ = msg; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + sbp_msg_ssr_gridded_correction_bounds_t last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds0, Test) { + uint8_t encoded_frame[] = { + 85, 254, 5, 66, 0, 43, 180, 0, 0, 0, 3, 0, 1, + 1, 10, 0, 15, 1, 0, 10, 0, 39, 232, 3, 244, 1, + 100, 200, 150, 100, 2, 5, 10, 16, 0, 17, 18, 19, 20, + 21, 6, 10, 22, 0, 23, 24, 25, 26, 27, 112, 145, + }; + + sbp_msg_ssr_gridded_correction_bounds_t test_msg{}; + test_msg.n_stub = 43; + + test_msg.stub[0] = 180; + + test_msg.stub[1] = 0; + + test_msg.stub[2] = 0; + + test_msg.stub[3] = 0; + + test_msg.stub[4] = 3; + + test_msg.stub[5] = 0; + + test_msg.stub[6] = 1; + + test_msg.stub[7] = 1; + + test_msg.stub[8] = 10; + + test_msg.stub[9] = 0; + + test_msg.stub[10] = 15; + + test_msg.stub[11] = 1; + + test_msg.stub[12] = 0; + + test_msg.stub[13] = 10; + + test_msg.stub[14] = 0; + + test_msg.stub[15] = 39; + + test_msg.stub[16] = 232; + + test_msg.stub[17] = 3; + + test_msg.stub[18] = 244; + + test_msg.stub[19] = 1; + + test_msg.stub[20] = 100; + + test_msg.stub[21] = 200; + + test_msg.stub[22] = 150; + + test_msg.stub[23] = 100; + + test_msg.stub[24] = 2; + + test_msg.stub[25] = 5; + + test_msg.stub[26] = 10; + + test_msg.stub[27] = 16; + + test_msg.stub[28] = 0; + + test_msg.stub[29] = 17; + + test_msg.stub[30] = 18; + + test_msg.stub[31] = 19; + + test_msg.stub[32] = 20; + + test_msg.stub[33] = 21; + + test_msg.stub[34] = 6; + + test_msg.stub[35] = 10; + + test_msg.stub[36] = 22; + + test_msg.stub[37] = 0; + + test_msg.stub[38] = 23; + + test_msg.stub[39] = 24; + + test_msg.stub[40] = 25; + + test_msg.stub[41] = 26; + + test_msg.stub[42] = 27; + + EXPECT_EQ(send_message(66, test_msg), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_, test_msg); + EXPECT_EQ(last_msg_.n_stub, 43) + << "incorrect value for last_msg_.n_stub, expected 43, is " + << last_msg_.n_stub; + EXPECT_EQ(last_msg_.stub[0], 180) + << "incorrect value for last_msg_.stub[0], expected 180, is " + << last_msg_.stub[0]; + EXPECT_EQ(last_msg_.stub[1], 0) + << "incorrect value for last_msg_.stub[1], expected 0, is " + << last_msg_.stub[1]; + EXPECT_EQ(last_msg_.stub[2], 0) + << "incorrect value for last_msg_.stub[2], expected 0, is " + << last_msg_.stub[2]; + EXPECT_EQ(last_msg_.stub[3], 0) + << "incorrect value for last_msg_.stub[3], expected 0, is " + << last_msg_.stub[3]; + EXPECT_EQ(last_msg_.stub[4], 3) + << "incorrect value for last_msg_.stub[4], expected 3, is " + << last_msg_.stub[4]; + EXPECT_EQ(last_msg_.stub[5], 0) + << "incorrect value for last_msg_.stub[5], expected 0, is " + << last_msg_.stub[5]; + EXPECT_EQ(last_msg_.stub[6], 1) + << "incorrect value for last_msg_.stub[6], expected 1, is " + << last_msg_.stub[6]; + EXPECT_EQ(last_msg_.stub[7], 1) + << "incorrect value for last_msg_.stub[7], expected 1, is " + << last_msg_.stub[7]; + EXPECT_EQ(last_msg_.stub[8], 10) + << "incorrect value for last_msg_.stub[8], expected 10, is " + << last_msg_.stub[8]; + EXPECT_EQ(last_msg_.stub[9], 0) + << "incorrect value for last_msg_.stub[9], expected 0, is " + << last_msg_.stub[9]; + EXPECT_EQ(last_msg_.stub[10], 15) + << "incorrect value for last_msg_.stub[10], expected 15, is " + << last_msg_.stub[10]; + EXPECT_EQ(last_msg_.stub[11], 1) + << "incorrect value for last_msg_.stub[11], expected 1, is " + << last_msg_.stub[11]; + EXPECT_EQ(last_msg_.stub[12], 0) + << "incorrect value for last_msg_.stub[12], expected 0, is " + << last_msg_.stub[12]; + EXPECT_EQ(last_msg_.stub[13], 10) + << "incorrect value for last_msg_.stub[13], expected 10, is " + << last_msg_.stub[13]; + EXPECT_EQ(last_msg_.stub[14], 0) + << "incorrect value for last_msg_.stub[14], expected 0, is " + << last_msg_.stub[14]; + EXPECT_EQ(last_msg_.stub[15], 39) + << "incorrect value for last_msg_.stub[15], expected 39, is " + << last_msg_.stub[15]; + EXPECT_EQ(last_msg_.stub[16], 232) + << "incorrect value for last_msg_.stub[16], expected 232, is " + << last_msg_.stub[16]; + EXPECT_EQ(last_msg_.stub[17], 3) + << "incorrect value for last_msg_.stub[17], expected 3, is " + << last_msg_.stub[17]; + EXPECT_EQ(last_msg_.stub[18], 244) + << "incorrect value for last_msg_.stub[18], expected 244, is " + << last_msg_.stub[18]; + EXPECT_EQ(last_msg_.stub[19], 1) + << "incorrect value for last_msg_.stub[19], expected 1, is " + << last_msg_.stub[19]; + EXPECT_EQ(last_msg_.stub[20], 100) + << "incorrect value for last_msg_.stub[20], expected 100, is " + << last_msg_.stub[20]; + EXPECT_EQ(last_msg_.stub[21], 200) + << "incorrect value for last_msg_.stub[21], expected 200, is " + << last_msg_.stub[21]; + EXPECT_EQ(last_msg_.stub[22], 150) + << "incorrect value for last_msg_.stub[22], expected 150, is " + << last_msg_.stub[22]; + EXPECT_EQ(last_msg_.stub[23], 100) + << "incorrect value for last_msg_.stub[23], expected 100, is " + << last_msg_.stub[23]; + EXPECT_EQ(last_msg_.stub[24], 2) + << "incorrect value for last_msg_.stub[24], expected 2, is " + << last_msg_.stub[24]; + EXPECT_EQ(last_msg_.stub[25], 5) + << "incorrect value for last_msg_.stub[25], expected 5, is " + << last_msg_.stub[25]; + EXPECT_EQ(last_msg_.stub[26], 10) + << "incorrect value for last_msg_.stub[26], expected 10, is " + << last_msg_.stub[26]; + EXPECT_EQ(last_msg_.stub[27], 16) + << "incorrect value for last_msg_.stub[27], expected 16, is " + << last_msg_.stub[27]; + EXPECT_EQ(last_msg_.stub[28], 0) + << "incorrect value for last_msg_.stub[28], expected 0, is " + << last_msg_.stub[28]; + EXPECT_EQ(last_msg_.stub[29], 17) + << "incorrect value for last_msg_.stub[29], expected 17, is " + << last_msg_.stub[29]; + EXPECT_EQ(last_msg_.stub[30], 18) + << "incorrect value for last_msg_.stub[30], expected 18, is " + << last_msg_.stub[30]; + EXPECT_EQ(last_msg_.stub[31], 19) + << "incorrect value for last_msg_.stub[31], expected 19, is " + << last_msg_.stub[31]; + EXPECT_EQ(last_msg_.stub[32], 20) + << "incorrect value for last_msg_.stub[32], expected 20, is " + << last_msg_.stub[32]; + EXPECT_EQ(last_msg_.stub[33], 21) + << "incorrect value for last_msg_.stub[33], expected 21, is " + << last_msg_.stub[33]; + EXPECT_EQ(last_msg_.stub[34], 6) + << "incorrect value for last_msg_.stub[34], expected 6, is " + << last_msg_.stub[34]; + EXPECT_EQ(last_msg_.stub[35], 10) + << "incorrect value for last_msg_.stub[35], expected 10, is " + << last_msg_.stub[35]; + EXPECT_EQ(last_msg_.stub[36], 22) + << "incorrect value for last_msg_.stub[36], expected 22, is " + << last_msg_.stub[36]; + EXPECT_EQ(last_msg_.stub[37], 0) + << "incorrect value for last_msg_.stub[37], expected 0, is " + << last_msg_.stub[37]; + EXPECT_EQ(last_msg_.stub[38], 23) + << "incorrect value for last_msg_.stub[38], expected 23, is " + << last_msg_.stub[38]; + EXPECT_EQ(last_msg_.stub[39], 24) + << "incorrect value for last_msg_.stub[39], expected 24, is " + << last_msg_.stub[39]; + EXPECT_EQ(last_msg_.stub[40], 25) + << "incorrect value for last_msg_.stub[40], expected 25, is " + << last_msg_.stub[40]; + EXPECT_EQ(last_msg_.stub[41], 26) + << "incorrect value for last_msg_.stub[41], expected 26, is " + << last_msg_.stub[41]; + EXPECT_EQ(last_msg_.stub[42], 27) + << "incorrect value for last_msg_.stub[42], expected 27, is " + << last_msg_.stub[42]; +} diff --git a/c/test/cpp/auto_check_sbp_ssr_MsgSsrOrbitClockBounds.cc b/c/test/cpp/auto_check_sbp_ssr_MsgSsrOrbitClockBounds.cc new file mode 100644 index 0000000000..2e4674515a --- /dev/null +++ b/c/test/cpp/auto_check_sbp_ssr_MsgSsrOrbitClockBounds.cc @@ -0,0 +1,257 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBounds.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +#include +class Test_auto_check_sbp_ssr_MsgSsrOrbitClockBounds0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::MessageHandler { + public: + Test_auto_check_sbp_ssr_MsgSsrOrbitClockBounds0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::MessageHandler(this), + last_msg_(), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, + const sbp_msg_ssr_orbit_clock_bounds_t &msg) override { + last_msg_ = msg; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + sbp_msg_ssr_orbit_clock_bounds_t last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_auto_check_sbp_ssr_MsgSsrOrbitClockBounds0, Test) { + uint8_t encoded_frame[] = { + 85, 222, 5, 66, 0, 31, 180, 0, 0, 0, 3, 0, 1, + 2, 3, 48, 15, 1, 2, 24, 39, 38, 37, 1, 2, 3, + 39, 1, 3, 39, 38, 37, 1, 2, 3, 39, 1, 21, 85, + }; + + sbp_msg_ssr_orbit_clock_bounds_t test_msg{}; + test_msg.n_stub = 31; + + test_msg.stub[0] = 180; + + test_msg.stub[1] = 0; + + test_msg.stub[2] = 0; + + test_msg.stub[3] = 0; + + test_msg.stub[4] = 3; + + test_msg.stub[5] = 0; + + test_msg.stub[6] = 1; + + test_msg.stub[7] = 2; + + test_msg.stub[8] = 3; + + test_msg.stub[9] = 48; + + test_msg.stub[10] = 15; + + test_msg.stub[11] = 1; + + test_msg.stub[12] = 2; + + test_msg.stub[13] = 24; + + test_msg.stub[14] = 39; + + test_msg.stub[15] = 38; + + test_msg.stub[16] = 37; + + test_msg.stub[17] = 1; + + test_msg.stub[18] = 2; + + test_msg.stub[19] = 3; + + test_msg.stub[20] = 39; + + test_msg.stub[21] = 1; + + test_msg.stub[22] = 3; + + test_msg.stub[23] = 39; + + test_msg.stub[24] = 38; + + test_msg.stub[25] = 37; + + test_msg.stub[26] = 1; + + test_msg.stub[27] = 2; + + test_msg.stub[28] = 3; + + test_msg.stub[29] = 39; + + test_msg.stub[30] = 1; + + EXPECT_EQ(send_message(66, test_msg), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_, test_msg); + EXPECT_EQ(last_msg_.n_stub, 31) + << "incorrect value for last_msg_.n_stub, expected 31, is " + << last_msg_.n_stub; + EXPECT_EQ(last_msg_.stub[0], 180) + << "incorrect value for last_msg_.stub[0], expected 180, is " + << last_msg_.stub[0]; + EXPECT_EQ(last_msg_.stub[1], 0) + << "incorrect value for last_msg_.stub[1], expected 0, is " + << last_msg_.stub[1]; + EXPECT_EQ(last_msg_.stub[2], 0) + << "incorrect value for last_msg_.stub[2], expected 0, is " + << last_msg_.stub[2]; + EXPECT_EQ(last_msg_.stub[3], 0) + << "incorrect value for last_msg_.stub[3], expected 0, is " + << last_msg_.stub[3]; + EXPECT_EQ(last_msg_.stub[4], 3) + << "incorrect value for last_msg_.stub[4], expected 3, is " + << last_msg_.stub[4]; + EXPECT_EQ(last_msg_.stub[5], 0) + << "incorrect value for last_msg_.stub[5], expected 0, is " + << last_msg_.stub[5]; + EXPECT_EQ(last_msg_.stub[6], 1) + << "incorrect value for last_msg_.stub[6], expected 1, is " + << last_msg_.stub[6]; + EXPECT_EQ(last_msg_.stub[7], 2) + << "incorrect value for last_msg_.stub[7], expected 2, is " + << last_msg_.stub[7]; + EXPECT_EQ(last_msg_.stub[8], 3) + << "incorrect value for last_msg_.stub[8], expected 3, is " + << last_msg_.stub[8]; + EXPECT_EQ(last_msg_.stub[9], 48) + << "incorrect value for last_msg_.stub[9], expected 48, is " + << last_msg_.stub[9]; + EXPECT_EQ(last_msg_.stub[10], 15) + << "incorrect value for last_msg_.stub[10], expected 15, is " + << last_msg_.stub[10]; + EXPECT_EQ(last_msg_.stub[11], 1) + << "incorrect value for last_msg_.stub[11], expected 1, is " + << last_msg_.stub[11]; + EXPECT_EQ(last_msg_.stub[12], 2) + << "incorrect value for last_msg_.stub[12], expected 2, is " + << last_msg_.stub[12]; + EXPECT_EQ(last_msg_.stub[13], 24) + << "incorrect value for last_msg_.stub[13], expected 24, is " + << last_msg_.stub[13]; + EXPECT_EQ(last_msg_.stub[14], 39) + << "incorrect value for last_msg_.stub[14], expected 39, is " + << last_msg_.stub[14]; + EXPECT_EQ(last_msg_.stub[15], 38) + << "incorrect value for last_msg_.stub[15], expected 38, is " + << last_msg_.stub[15]; + EXPECT_EQ(last_msg_.stub[16], 37) + << "incorrect value for last_msg_.stub[16], expected 37, is " + << last_msg_.stub[16]; + EXPECT_EQ(last_msg_.stub[17], 1) + << "incorrect value for last_msg_.stub[17], expected 1, is " + << last_msg_.stub[17]; + EXPECT_EQ(last_msg_.stub[18], 2) + << "incorrect value for last_msg_.stub[18], expected 2, is " + << last_msg_.stub[18]; + EXPECT_EQ(last_msg_.stub[19], 3) + << "incorrect value for last_msg_.stub[19], expected 3, is " + << last_msg_.stub[19]; + EXPECT_EQ(last_msg_.stub[20], 39) + << "incorrect value for last_msg_.stub[20], expected 39, is " + << last_msg_.stub[20]; + EXPECT_EQ(last_msg_.stub[21], 1) + << "incorrect value for last_msg_.stub[21], expected 1, is " + << last_msg_.stub[21]; + EXPECT_EQ(last_msg_.stub[22], 3) + << "incorrect value for last_msg_.stub[22], expected 3, is " + << last_msg_.stub[22]; + EXPECT_EQ(last_msg_.stub[23], 39) + << "incorrect value for last_msg_.stub[23], expected 39, is " + << last_msg_.stub[23]; + EXPECT_EQ(last_msg_.stub[24], 38) + << "incorrect value for last_msg_.stub[24], expected 38, is " + << last_msg_.stub[24]; + EXPECT_EQ(last_msg_.stub[25], 37) + << "incorrect value for last_msg_.stub[25], expected 37, is " + << last_msg_.stub[25]; + EXPECT_EQ(last_msg_.stub[26], 1) + << "incorrect value for last_msg_.stub[26], expected 1, is " + << last_msg_.stub[26]; + EXPECT_EQ(last_msg_.stub[27], 2) + << "incorrect value for last_msg_.stub[27], expected 2, is " + << last_msg_.stub[27]; + EXPECT_EQ(last_msg_.stub[28], 3) + << "incorrect value for last_msg_.stub[28], expected 3, is " + << last_msg_.stub[28]; + EXPECT_EQ(last_msg_.stub[29], 39) + << "incorrect value for last_msg_.stub[29], expected 39, is " + << last_msg_.stub[29]; + EXPECT_EQ(last_msg_.stub[30], 1) + << "incorrect value for last_msg_.stub[30], expected 1, is " + << last_msg_.stub[30]; +} diff --git a/c/test/cpp/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation.cc b/c/test/cpp/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation.cc new file mode 100644 index 0000000000..09b4e7f671 --- /dev/null +++ b/c/test/cpp/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation.cc @@ -0,0 +1,243 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBoundsDegradation.yaml +// by generate.py. Do not modify by hand! + +#include +#include +#include +#include +#include +class Test_auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::MessageHandler { + public: + Test_auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::MessageHandler(this), + last_msg_(), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg( + uint16_t sender_id, + const sbp_msg_ssr_orbit_clock_bounds_degradation_t &msg) override { + last_msg_ = msg; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + sbp_msg_ssr_orbit_clock_bounds_degradation_t last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation0, Test) { + uint8_t encoded_frame[] = { + 85, 223, 5, 66, 0, 28, 180, 0, 0, 0, 3, 0, + 1, 2, 3, 48, 15, 1, 10, 0, 0, 0, 0, 0, + 0, 0, 200, 199, 198, 197, 196, 195, 194, 193, 200, 117, + }; + + sbp_msg_ssr_orbit_clock_bounds_degradation_t test_msg{}; + test_msg.n_stub = 28; + + test_msg.stub[0] = 180; + + test_msg.stub[1] = 0; + + test_msg.stub[2] = 0; + + test_msg.stub[3] = 0; + + test_msg.stub[4] = 3; + + test_msg.stub[5] = 0; + + test_msg.stub[6] = 1; + + test_msg.stub[7] = 2; + + test_msg.stub[8] = 3; + + test_msg.stub[9] = 48; + + test_msg.stub[10] = 15; + + test_msg.stub[11] = 1; + + test_msg.stub[12] = 10; + + test_msg.stub[13] = 0; + + test_msg.stub[14] = 0; + + test_msg.stub[15] = 0; + + test_msg.stub[16] = 0; + + test_msg.stub[17] = 0; + + test_msg.stub[18] = 0; + + test_msg.stub[19] = 0; + + test_msg.stub[20] = 200; + + test_msg.stub[21] = 199; + + test_msg.stub[22] = 198; + + test_msg.stub[23] = 197; + + test_msg.stub[24] = 196; + + test_msg.stub[25] = 195; + + test_msg.stub[26] = 194; + + test_msg.stub[27] = 193; + + EXPECT_EQ(send_message(66, test_msg), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_, test_msg); + EXPECT_EQ(last_msg_.n_stub, 28) + << "incorrect value for last_msg_.n_stub, expected 28, is " + << last_msg_.n_stub; + EXPECT_EQ(last_msg_.stub[0], 180) + << "incorrect value for last_msg_.stub[0], expected 180, is " + << last_msg_.stub[0]; + EXPECT_EQ(last_msg_.stub[1], 0) + << "incorrect value for last_msg_.stub[1], expected 0, is " + << last_msg_.stub[1]; + EXPECT_EQ(last_msg_.stub[2], 0) + << "incorrect value for last_msg_.stub[2], expected 0, is " + << last_msg_.stub[2]; + EXPECT_EQ(last_msg_.stub[3], 0) + << "incorrect value for last_msg_.stub[3], expected 0, is " + << last_msg_.stub[3]; + EXPECT_EQ(last_msg_.stub[4], 3) + << "incorrect value for last_msg_.stub[4], expected 3, is " + << last_msg_.stub[4]; + EXPECT_EQ(last_msg_.stub[5], 0) + << "incorrect value for last_msg_.stub[5], expected 0, is " + << last_msg_.stub[5]; + EXPECT_EQ(last_msg_.stub[6], 1) + << "incorrect value for last_msg_.stub[6], expected 1, is " + << last_msg_.stub[6]; + EXPECT_EQ(last_msg_.stub[7], 2) + << "incorrect value for last_msg_.stub[7], expected 2, is " + << last_msg_.stub[7]; + EXPECT_EQ(last_msg_.stub[8], 3) + << "incorrect value for last_msg_.stub[8], expected 3, is " + << last_msg_.stub[8]; + EXPECT_EQ(last_msg_.stub[9], 48) + << "incorrect value for last_msg_.stub[9], expected 48, is " + << last_msg_.stub[9]; + EXPECT_EQ(last_msg_.stub[10], 15) + << "incorrect value for last_msg_.stub[10], expected 15, is " + << last_msg_.stub[10]; + EXPECT_EQ(last_msg_.stub[11], 1) + << "incorrect value for last_msg_.stub[11], expected 1, is " + << last_msg_.stub[11]; + EXPECT_EQ(last_msg_.stub[12], 10) + << "incorrect value for last_msg_.stub[12], expected 10, is " + << last_msg_.stub[12]; + EXPECT_EQ(last_msg_.stub[13], 0) + << "incorrect value for last_msg_.stub[13], expected 0, is " + << last_msg_.stub[13]; + EXPECT_EQ(last_msg_.stub[14], 0) + << "incorrect value for last_msg_.stub[14], expected 0, is " + << last_msg_.stub[14]; + EXPECT_EQ(last_msg_.stub[15], 0) + << "incorrect value for last_msg_.stub[15], expected 0, is " + << last_msg_.stub[15]; + EXPECT_EQ(last_msg_.stub[16], 0) + << "incorrect value for last_msg_.stub[16], expected 0, is " + << last_msg_.stub[16]; + EXPECT_EQ(last_msg_.stub[17], 0) + << "incorrect value for last_msg_.stub[17], expected 0, is " + << last_msg_.stub[17]; + EXPECT_EQ(last_msg_.stub[18], 0) + << "incorrect value for last_msg_.stub[18], expected 0, is " + << last_msg_.stub[18]; + EXPECT_EQ(last_msg_.stub[19], 0) + << "incorrect value for last_msg_.stub[19], expected 0, is " + << last_msg_.stub[19]; + EXPECT_EQ(last_msg_.stub[20], 200) + << "incorrect value for last_msg_.stub[20], expected 200, is " + << last_msg_.stub[20]; + EXPECT_EQ(last_msg_.stub[21], 199) + << "incorrect value for last_msg_.stub[21], expected 199, is " + << last_msg_.stub[21]; + EXPECT_EQ(last_msg_.stub[22], 198) + << "incorrect value for last_msg_.stub[22], expected 198, is " + << last_msg_.stub[22]; + EXPECT_EQ(last_msg_.stub[23], 197) + << "incorrect value for last_msg_.stub[23], expected 197, is " + << last_msg_.stub[23]; + EXPECT_EQ(last_msg_.stub[24], 196) + << "incorrect value for last_msg_.stub[24], expected 196, is " + << last_msg_.stub[24]; + EXPECT_EQ(last_msg_.stub[25], 195) + << "incorrect value for last_msg_.stub[25], expected 195, is " + << last_msg_.stub[25]; + EXPECT_EQ(last_msg_.stub[26], 194) + << "incorrect value for last_msg_.stub[26], expected 194, is " + << last_msg_.stub[26]; + EXPECT_EQ(last_msg_.stub[27], 193) + << "incorrect value for last_msg_.stub[27], expected 193, is " + << last_msg_.stub[27]; +} diff --git a/c/test/cpp/auto_check_sbp_ssr_MsgSsrStecCorrection.cc b/c/test/cpp/auto_check_sbp_ssr_MsgSsrStecCorrection.cc new file mode 100644 index 0000000000..79577772b9 --- /dev/null +++ b/c/test/cpp/auto_check_sbp_ssr_MsgSsrStecCorrection.cc @@ -0,0 +1,292 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrStecCorrection.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +#include +class Test_auto_check_sbp_ssr_MsgSsrStecCorrection0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::MessageHandler { + public: + Test_auto_check_sbp_ssr_MsgSsrStecCorrection0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::MessageHandler(this), + last_msg_(), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, + const sbp_msg_ssr_stec_correction_t &msg) override { + last_msg_ = msg; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + sbp_msg_ssr_stec_correction_t last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_auto_check_sbp_ssr_MsgSsrStecCorrection0, Test) { + uint8_t encoded_frame[] = { + 85, 253, 5, 66, 0, 38, 180, 0, 0, 0, 3, 0, 1, 1, 10, 0, + 15, 1, 0, 10, 0, 2, 1, 1, 1, 63, 0, 62, 0, 61, 0, 60, + 0, 31, 15, 5, 63, 0, 64, 0, 65, 0, 66, 0, 119, 50, + }; + + sbp_msg_ssr_stec_correction_t test_msg{}; + test_msg.n_stub = 38; + + test_msg.stub[0] = 180; + + test_msg.stub[1] = 0; + + test_msg.stub[2] = 0; + + test_msg.stub[3] = 0; + + test_msg.stub[4] = 3; + + test_msg.stub[5] = 0; + + test_msg.stub[6] = 1; + + test_msg.stub[7] = 1; + + test_msg.stub[8] = 10; + + test_msg.stub[9] = 0; + + test_msg.stub[10] = 15; + + test_msg.stub[11] = 1; + + test_msg.stub[12] = 0; + + test_msg.stub[13] = 10; + + test_msg.stub[14] = 0; + + test_msg.stub[15] = 2; + + test_msg.stub[16] = 1; + + test_msg.stub[17] = 1; + + test_msg.stub[18] = 1; + + test_msg.stub[19] = 63; + + test_msg.stub[20] = 0; + + test_msg.stub[21] = 62; + + test_msg.stub[22] = 0; + + test_msg.stub[23] = 61; + + test_msg.stub[24] = 0; + + test_msg.stub[25] = 60; + + test_msg.stub[26] = 0; + + test_msg.stub[27] = 31; + + test_msg.stub[28] = 15; + + test_msg.stub[29] = 5; + + test_msg.stub[30] = 63; + + test_msg.stub[31] = 0; + + test_msg.stub[32] = 64; + + test_msg.stub[33] = 0; + + test_msg.stub[34] = 65; + + test_msg.stub[35] = 0; + + test_msg.stub[36] = 66; + + test_msg.stub[37] = 0; + + EXPECT_EQ(send_message(66, test_msg), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_, test_msg); + EXPECT_EQ(last_msg_.n_stub, 38) + << "incorrect value for last_msg_.n_stub, expected 38, is " + << last_msg_.n_stub; + EXPECT_EQ(last_msg_.stub[0], 180) + << "incorrect value for last_msg_.stub[0], expected 180, is " + << last_msg_.stub[0]; + EXPECT_EQ(last_msg_.stub[1], 0) + << "incorrect value for last_msg_.stub[1], expected 0, is " + << last_msg_.stub[1]; + EXPECT_EQ(last_msg_.stub[2], 0) + << "incorrect value for last_msg_.stub[2], expected 0, is " + << last_msg_.stub[2]; + EXPECT_EQ(last_msg_.stub[3], 0) + << "incorrect value for last_msg_.stub[3], expected 0, is " + << last_msg_.stub[3]; + EXPECT_EQ(last_msg_.stub[4], 3) + << "incorrect value for last_msg_.stub[4], expected 3, is " + << last_msg_.stub[4]; + EXPECT_EQ(last_msg_.stub[5], 0) + << "incorrect value for last_msg_.stub[5], expected 0, is " + << last_msg_.stub[5]; + EXPECT_EQ(last_msg_.stub[6], 1) + << "incorrect value for last_msg_.stub[6], expected 1, is " + << last_msg_.stub[6]; + EXPECT_EQ(last_msg_.stub[7], 1) + << "incorrect value for last_msg_.stub[7], expected 1, is " + << last_msg_.stub[7]; + EXPECT_EQ(last_msg_.stub[8], 10) + << "incorrect value for last_msg_.stub[8], expected 10, is " + << last_msg_.stub[8]; + EXPECT_EQ(last_msg_.stub[9], 0) + << "incorrect value for last_msg_.stub[9], expected 0, is " + << last_msg_.stub[9]; + EXPECT_EQ(last_msg_.stub[10], 15) + << "incorrect value for last_msg_.stub[10], expected 15, is " + << last_msg_.stub[10]; + EXPECT_EQ(last_msg_.stub[11], 1) + << "incorrect value for last_msg_.stub[11], expected 1, is " + << last_msg_.stub[11]; + EXPECT_EQ(last_msg_.stub[12], 0) + << "incorrect value for last_msg_.stub[12], expected 0, is " + << last_msg_.stub[12]; + EXPECT_EQ(last_msg_.stub[13], 10) + << "incorrect value for last_msg_.stub[13], expected 10, is " + << last_msg_.stub[13]; + EXPECT_EQ(last_msg_.stub[14], 0) + << "incorrect value for last_msg_.stub[14], expected 0, is " + << last_msg_.stub[14]; + EXPECT_EQ(last_msg_.stub[15], 2) + << "incorrect value for last_msg_.stub[15], expected 2, is " + << last_msg_.stub[15]; + EXPECT_EQ(last_msg_.stub[16], 1) + << "incorrect value for last_msg_.stub[16], expected 1, is " + << last_msg_.stub[16]; + EXPECT_EQ(last_msg_.stub[17], 1) + << "incorrect value for last_msg_.stub[17], expected 1, is " + << last_msg_.stub[17]; + EXPECT_EQ(last_msg_.stub[18], 1) + << "incorrect value for last_msg_.stub[18], expected 1, is " + << last_msg_.stub[18]; + EXPECT_EQ(last_msg_.stub[19], 63) + << "incorrect value for last_msg_.stub[19], expected 63, is " + << last_msg_.stub[19]; + EXPECT_EQ(last_msg_.stub[20], 0) + << "incorrect value for last_msg_.stub[20], expected 0, is " + << last_msg_.stub[20]; + EXPECT_EQ(last_msg_.stub[21], 62) + << "incorrect value for last_msg_.stub[21], expected 62, is " + << last_msg_.stub[21]; + EXPECT_EQ(last_msg_.stub[22], 0) + << "incorrect value for last_msg_.stub[22], expected 0, is " + << last_msg_.stub[22]; + EXPECT_EQ(last_msg_.stub[23], 61) + << "incorrect value for last_msg_.stub[23], expected 61, is " + << last_msg_.stub[23]; + EXPECT_EQ(last_msg_.stub[24], 0) + << "incorrect value for last_msg_.stub[24], expected 0, is " + << last_msg_.stub[24]; + EXPECT_EQ(last_msg_.stub[25], 60) + << "incorrect value for last_msg_.stub[25], expected 60, is " + << last_msg_.stub[25]; + EXPECT_EQ(last_msg_.stub[26], 0) + << "incorrect value for last_msg_.stub[26], expected 0, is " + << last_msg_.stub[26]; + EXPECT_EQ(last_msg_.stub[27], 31) + << "incorrect value for last_msg_.stub[27], expected 31, is " + << last_msg_.stub[27]; + EXPECT_EQ(last_msg_.stub[28], 15) + << "incorrect value for last_msg_.stub[28], expected 15, is " + << last_msg_.stub[28]; + EXPECT_EQ(last_msg_.stub[29], 5) + << "incorrect value for last_msg_.stub[29], expected 5, is " + << last_msg_.stub[29]; + EXPECT_EQ(last_msg_.stub[30], 63) + << "incorrect value for last_msg_.stub[30], expected 63, is " + << last_msg_.stub[30]; + EXPECT_EQ(last_msg_.stub[31], 0) + << "incorrect value for last_msg_.stub[31], expected 0, is " + << last_msg_.stub[31]; + EXPECT_EQ(last_msg_.stub[32], 64) + << "incorrect value for last_msg_.stub[32], expected 64, is " + << last_msg_.stub[32]; + EXPECT_EQ(last_msg_.stub[33], 0) + << "incorrect value for last_msg_.stub[33], expected 0, is " + << last_msg_.stub[33]; + EXPECT_EQ(last_msg_.stub[34], 65) + << "incorrect value for last_msg_.stub[34], expected 65, is " + << last_msg_.stub[34]; + EXPECT_EQ(last_msg_.stub[35], 0) + << "incorrect value for last_msg_.stub[35], expected 0, is " + << last_msg_.stub[35]; + EXPECT_EQ(last_msg_.stub[36], 66) + << "incorrect value for last_msg_.stub[36], expected 66, is " + << last_msg_.stub[36]; + EXPECT_EQ(last_msg_.stub[37], 0) + << "incorrect value for last_msg_.stub[37], expected 0, is " + << last_msg_.stub[37]; +} diff --git a/c/test/cpp/auto_check_sbp_ssr_MsgSsrTileDefinition.cc b/c/test/cpp/auto_check_sbp_ssr_MsgSsrTileDefinition.cc new file mode 100644 index 0000000000..abe2ff0ce0 --- /dev/null +++ b/c/test/cpp/auto_check_sbp_ssr_MsgSsrTileDefinition.cc @@ -0,0 +1,226 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrTileDefinition.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +#include +class Test_auto_check_sbp_ssr_MsgSsrTileDefinition0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::MessageHandler { + public: + Test_auto_check_sbp_ssr_MsgSsrTileDefinition0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::MessageHandler(this), + last_msg_(), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, + const sbp_msg_ssr_tile_definition_t &msg) override { + last_msg_ = msg; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + sbp_msg_ssr_tile_definition_t last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_auto_check_sbp_ssr_MsgSsrTileDefinition0, Test) { + uint8_t encoded_frame[] = { + 85, 247, 5, 66, 0, 25, 31, 0, 1, 0, 2, 0, 4, 0, 8, 0, 16, + 0, 32, 0, 64, 0, 128, 210, 2, 150, 73, 0, 0, 0, 0, 214, 71, + }; + + sbp_msg_ssr_tile_definition_t test_msg{}; + test_msg.n_stub = 25; + + test_msg.stub[0] = 31; + + test_msg.stub[1] = 0; + + test_msg.stub[2] = 1; + + test_msg.stub[3] = 0; + + test_msg.stub[4] = 2; + + test_msg.stub[5] = 0; + + test_msg.stub[6] = 4; + + test_msg.stub[7] = 0; + + test_msg.stub[8] = 8; + + test_msg.stub[9] = 0; + + test_msg.stub[10] = 16; + + test_msg.stub[11] = 0; + + test_msg.stub[12] = 32; + + test_msg.stub[13] = 0; + + test_msg.stub[14] = 64; + + test_msg.stub[15] = 0; + + test_msg.stub[16] = 128; + + test_msg.stub[17] = 210; + + test_msg.stub[18] = 2; + + test_msg.stub[19] = 150; + + test_msg.stub[20] = 73; + + test_msg.stub[21] = 0; + + test_msg.stub[22] = 0; + + test_msg.stub[23] = 0; + + test_msg.stub[24] = 0; + + EXPECT_EQ(send_message(66, test_msg), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_, test_msg); + EXPECT_EQ(last_msg_.n_stub, 25) + << "incorrect value for last_msg_.n_stub, expected 25, is " + << last_msg_.n_stub; + EXPECT_EQ(last_msg_.stub[0], 31) + << "incorrect value for last_msg_.stub[0], expected 31, is " + << last_msg_.stub[0]; + EXPECT_EQ(last_msg_.stub[1], 0) + << "incorrect value for last_msg_.stub[1], expected 0, is " + << last_msg_.stub[1]; + EXPECT_EQ(last_msg_.stub[2], 1) + << "incorrect value for last_msg_.stub[2], expected 1, is " + << last_msg_.stub[2]; + EXPECT_EQ(last_msg_.stub[3], 0) + << "incorrect value for last_msg_.stub[3], expected 0, is " + << last_msg_.stub[3]; + EXPECT_EQ(last_msg_.stub[4], 2) + << "incorrect value for last_msg_.stub[4], expected 2, is " + << last_msg_.stub[4]; + EXPECT_EQ(last_msg_.stub[5], 0) + << "incorrect value for last_msg_.stub[5], expected 0, is " + << last_msg_.stub[5]; + EXPECT_EQ(last_msg_.stub[6], 4) + << "incorrect value for last_msg_.stub[6], expected 4, is " + << last_msg_.stub[6]; + EXPECT_EQ(last_msg_.stub[7], 0) + << "incorrect value for last_msg_.stub[7], expected 0, is " + << last_msg_.stub[7]; + EXPECT_EQ(last_msg_.stub[8], 8) + << "incorrect value for last_msg_.stub[8], expected 8, is " + << last_msg_.stub[8]; + EXPECT_EQ(last_msg_.stub[9], 0) + << "incorrect value for last_msg_.stub[9], expected 0, is " + << last_msg_.stub[9]; + EXPECT_EQ(last_msg_.stub[10], 16) + << "incorrect value for last_msg_.stub[10], expected 16, is " + << last_msg_.stub[10]; + EXPECT_EQ(last_msg_.stub[11], 0) + << "incorrect value for last_msg_.stub[11], expected 0, is " + << last_msg_.stub[11]; + EXPECT_EQ(last_msg_.stub[12], 32) + << "incorrect value for last_msg_.stub[12], expected 32, is " + << last_msg_.stub[12]; + EXPECT_EQ(last_msg_.stub[13], 0) + << "incorrect value for last_msg_.stub[13], expected 0, is " + << last_msg_.stub[13]; + EXPECT_EQ(last_msg_.stub[14], 64) + << "incorrect value for last_msg_.stub[14], expected 64, is " + << last_msg_.stub[14]; + EXPECT_EQ(last_msg_.stub[15], 0) + << "incorrect value for last_msg_.stub[15], expected 0, is " + << last_msg_.stub[15]; + EXPECT_EQ(last_msg_.stub[16], 128) + << "incorrect value for last_msg_.stub[16], expected 128, is " + << last_msg_.stub[16]; + EXPECT_EQ(last_msg_.stub[17], 210) + << "incorrect value for last_msg_.stub[17], expected 210, is " + << last_msg_.stub[17]; + EXPECT_EQ(last_msg_.stub[18], 2) + << "incorrect value for last_msg_.stub[18], expected 2, is " + << last_msg_.stub[18]; + EXPECT_EQ(last_msg_.stub[19], 150) + << "incorrect value for last_msg_.stub[19], expected 150, is " + << last_msg_.stub[19]; + EXPECT_EQ(last_msg_.stub[20], 73) + << "incorrect value for last_msg_.stub[20], expected 73, is " + << last_msg_.stub[20]; + EXPECT_EQ(last_msg_.stub[21], 0) + << "incorrect value for last_msg_.stub[21], expected 0, is " + << last_msg_.stub[21]; + EXPECT_EQ(last_msg_.stub[22], 0) + << "incorrect value for last_msg_.stub[22], expected 0, is " + << last_msg_.stub[22]; + EXPECT_EQ(last_msg_.stub[23], 0) + << "incorrect value for last_msg_.stub[23], expected 0, is " + << last_msg_.stub[23]; + EXPECT_EQ(last_msg_.stub[24], 0) + << "incorrect value for last_msg_.stub[24], expected 0, is " + << last_msg_.stub[24]; +} diff --git a/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c b/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c new file mode 100644 index 0000000000..e621df5a6d --- /dev/null +++ b/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c @@ -0,0 +1,455 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u8 len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + void *context; +} last_msg; + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u16 msg_type; + u8 msg_len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + u16 frame_len; + u8 frame[SBP_MAX_FRAME_LEN]; + void *context; +} last_frame; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static int DUMMY_MEMORY_FOR_CALLBACKS = 0xdeadbeef; +static int DUMMY_MEMORY_FOR_IO = 0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return real_n; +} + +static void logging_reset() { + memset(&last_msg, 0, sizeof(last_msg)); + memset(&last_frame, 0, sizeof(last_frame)); +} + +static void msg_callback(u16 sender_id, u8 len, u8 msg[], void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.len = len; + last_msg.context = context; + memcpy(last_msg.msg, msg, len); +} + +static void frame_callback(u16 sender_id, u16 msg_type, u8 msg_len, u8 msg[], + u16 frame_len, u8 frame[], void *context) { + last_frame.n_callbacks_logged++; + last_frame.sender_id = sender_id; + last_frame.msg_type = msg_type; + last_frame.msg_len = msg_len; + memcpy(last_frame.msg, msg, msg_len); + last_frame.frame_len = frame_len; + memcpy(last_frame.frame, frame, frame_len); + last_frame.context = context; +} + +START_TEST(test_legacy_auto_check_sbp_integrity_MsgSsrFlagHighLevel) { + static sbp_msg_callbacks_node_t n; + static sbp_msg_callbacks_node_t n2; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_payload_callback_register(&sbp_state, 3001, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + sbp_frame_callback_register(&sbp_state, 3001, &frame_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n2); + + u8 encoded_frame[] = { + 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, + 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, 1, 2, + 3, 0, 0, 0, 0, 0, 0, 4, 5, 6, 7, 102, 67, + }; + + dummy_reset(); + + u8 test_msg_storage[SBP_MAX_PAYLOAD_LEN]; + memset(test_msg_storage, 0, sizeof(test_msg_storage)); + u8 test_msg_len = 0; + msg_ssr_flag_high_level_t *test_msg = + (msg_ssr_flag_high_level_t *)test_msg_storage; + test_msg_len = sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[6] = 104; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[7] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[8] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[9] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[10] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[11] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[12] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[13] = 20; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[14] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[15] = 30; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[16] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[17] = 40; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[18] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[19] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[20] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[21] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[22] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[23] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[24] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[25] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[26] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[27] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[28] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[29] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[30] = 7; + sbp_payload_send(&sbp_state, 3001, 66, test_msg_len, test_msg_storage, + &dummy_write); + + ck_assert_msg( + test_msg_len == sizeof(encoded_frame) - 8, + "Test message has not been generated correctly, or the encoded frame " + "from the spec is badly defined. Check your test spec"); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff"); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_msg.len == sizeof(encoded_frame) - 8, + "msg_callback: len decoded incorrectly"); + ck_assert_msg( + memcmp(last_msg.msg, encoded_frame + 6, sizeof(encoded_frame) - 8) == 0, + "msg_callback: test data decoded incorrectly"); + ck_assert_msg(last_msg.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + ck_assert_msg(last_frame.n_callbacks_logged == 1, + "frame_callback: one callback should have been logged"); + ck_assert_msg(last_frame.sender_id == 66, + "frame_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_frame.msg_type == 3001, + "frame_callback: msg_type decoded incorrectly"); + ck_assert_msg(last_frame.msg_len == sizeof(encoded_frame) - 8, + "frame_callback: msg_len decoded incorrectly"); + ck_assert_msg(memcmp(last_frame.msg, encoded_frame + 6, + sizeof(encoded_frame) - 8) == 0, + "frame_callback: test data decoded incorrectly"); + ck_assert_msg(last_frame.frame_len == sizeof(encoded_frame), + "frame_callback: frame_len decoded incorrectly"); + ck_assert_msg( + memcmp(last_frame.frame, encoded_frame, sizeof(encoded_frame)) == 0, + "frame_callback: frame decoded incorrectly"); + ck_assert_msg(last_frame.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + // Cast to expected message type - the +6 byte offset is where the payload + // starts + msg_ssr_flag_high_level_t *check_msg = + (msg_ssr_flag_high_level_t *)((void *)last_msg.msg); + // Run tests against fields + ck_assert_msg(check_msg != 0, "stub to prevent warnings if msg isn't used"); + ck_assert_msg(check_msg->stub[0] == 180, + "incorrect value for stub[0], expected 180, is %d", + check_msg->stub[0]); + ck_assert_msg(check_msg->stub[1] == 0, + "incorrect value for stub[1], expected 0, is %d", + check_msg->stub[1]); + ck_assert_msg(check_msg->stub[2] == 0, + "incorrect value for stub[2], expected 0, is %d", + check_msg->stub[2]); + ck_assert_msg(check_msg->stub[3] == 0, + "incorrect value for stub[3], expected 0, is %d", + check_msg->stub[3]); + ck_assert_msg(check_msg->stub[4] == 3, + "incorrect value for stub[4], expected 3, is %d", + check_msg->stub[4]); + ck_assert_msg(check_msg->stub[5] == 0, + "incorrect value for stub[5], expected 0, is %d", + check_msg->stub[5]); + ck_assert_msg(check_msg->stub[6] == 104, + "incorrect value for stub[6], expected 104, is %d", + check_msg->stub[6]); + ck_assert_msg(check_msg->stub[7] == 1, + "incorrect value for stub[7], expected 1, is %d", + check_msg->stub[7]); + ck_assert_msg(check_msg->stub[8] == 0, + "incorrect value for stub[8], expected 0, is %d", + check_msg->stub[8]); + ck_assert_msg(check_msg->stub[9] == 0, + "incorrect value for stub[9], expected 0, is %d", + check_msg->stub[9]); + ck_assert_msg(check_msg->stub[10] == 6, + "incorrect value for stub[10], expected 6, is %d", + check_msg->stub[10]); + ck_assert_msg(check_msg->stub[11] == 0, + "incorrect value for stub[11], expected 0, is %d", + check_msg->stub[11]); + ck_assert_msg(check_msg->stub[12] == 10, + "incorrect value for stub[12], expected 10, is %d", + check_msg->stub[12]); + ck_assert_msg(check_msg->stub[13] == 20, + "incorrect value for stub[13], expected 20, is %d", + check_msg->stub[13]); + ck_assert_msg(check_msg->stub[14] == 0, + "incorrect value for stub[14], expected 0, is %d", + check_msg->stub[14]); + ck_assert_msg(check_msg->stub[15] == 30, + "incorrect value for stub[15], expected 30, is %d", + check_msg->stub[15]); + ck_assert_msg(check_msg->stub[16] == 0, + "incorrect value for stub[16], expected 0, is %d", + check_msg->stub[16]); + ck_assert_msg(check_msg->stub[17] == 40, + "incorrect value for stub[17], expected 40, is %d", + check_msg->stub[17]); + ck_assert_msg(check_msg->stub[18] == 1, + "incorrect value for stub[18], expected 1, is %d", + check_msg->stub[18]); + ck_assert_msg(check_msg->stub[19] == 2, + "incorrect value for stub[19], expected 2, is %d", + check_msg->stub[19]); + ck_assert_msg(check_msg->stub[20] == 3, + "incorrect value for stub[20], expected 3, is %d", + check_msg->stub[20]); + ck_assert_msg(check_msg->stub[21] == 0, + "incorrect value for stub[21], expected 0, is %d", + check_msg->stub[21]); + ck_assert_msg(check_msg->stub[22] == 0, + "incorrect value for stub[22], expected 0, is %d", + check_msg->stub[22]); + ck_assert_msg(check_msg->stub[23] == 0, + "incorrect value for stub[23], expected 0, is %d", + check_msg->stub[23]); + ck_assert_msg(check_msg->stub[24] == 0, + "incorrect value for stub[24], expected 0, is %d", + check_msg->stub[24]); + ck_assert_msg(check_msg->stub[25] == 0, + "incorrect value for stub[25], expected 0, is %d", + check_msg->stub[25]); + ck_assert_msg(check_msg->stub[26] == 0, + "incorrect value for stub[26], expected 0, is %d", + check_msg->stub[26]); + ck_assert_msg(check_msg->stub[27] == 4, + "incorrect value for stub[27], expected 4, is %d", + check_msg->stub[27]); + ck_assert_msg(check_msg->stub[28] == 5, + "incorrect value for stub[28], expected 5, is %d", + check_msg->stub[28]); + ck_assert_msg(check_msg->stub[29] == 6, + "incorrect value for stub[29], expected 6, is %d", + check_msg->stub[29]); + ck_assert_msg(check_msg->stub[30] == 7, + "incorrect value for stub[30], expected 7, is %d", + check_msg->stub[30]); + } +} +END_TEST + +Suite *legacy_auto_check_sbp_integrity_MsgSsrFlagHighLevel_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "legacy_auto_check_sbp_integrity_MsgSsrFlagHighLevel"); + TCase *tc_acq = tcase_create( + "Automated_Suite_legacy_auto_check_sbp_integrity_MsgSsrFlagHighLevel"); + tcase_add_test(tc_acq, + test_legacy_auto_check_sbp_integrity_MsgSsrFlagHighLevel); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos.c b/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos.c new file mode 100644 index 0000000000..2e494b5b0e --- /dev/null +++ b/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos.c @@ -0,0 +1,377 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPointSatLos.yaml +// by generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u8 len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + void *context; +} last_msg; + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u16 msg_type; + u8 msg_len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + u16 frame_len; + u8 frame[SBP_MAX_FRAME_LEN]; + void *context; +} last_frame; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static int DUMMY_MEMORY_FOR_CALLBACKS = 0xdeadbeef; +static int DUMMY_MEMORY_FOR_IO = 0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return real_n; +} + +static void logging_reset() { + memset(&last_msg, 0, sizeof(last_msg)); + memset(&last_frame, 0, sizeof(last_frame)); +} + +static void msg_callback(u16 sender_id, u8 len, u8 msg[], void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.len = len; + last_msg.context = context; + memcpy(last_msg.msg, msg, len); +} + +static void frame_callback(u16 sender_id, u16 msg_type, u8 msg_len, u8 msg[], + u16 frame_len, u8 frame[], void *context) { + last_frame.n_callbacks_logged++; + last_frame.sender_id = sender_id; + last_frame.msg_type = msg_type; + last_frame.msg_len = msg_len; + memcpy(last_frame.msg, msg, msg_len); + last_frame.frame_len = frame_len; + memcpy(last_frame.frame, frame, frame_len); + last_frame.context = context; +} + +START_TEST(test_legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos) { + static sbp_msg_callbacks_node_t n; + static sbp_msg_callbacks_node_t n2; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_payload_callback_register(&sbp_state, 3025, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + sbp_frame_callback_register(&sbp_state, 3025, &frame_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n2); + + u8 encoded_frame[] = { + 85, 209, 11, 66, 0, 21, 180, 0, 0, 0, 3, 0, 1, 2, 3, + 4, 0, 5, 0, 6, 30, 0, 2, 10, 11, 15, 14, 98, 148, + }; + + dummy_reset(); + + u8 test_msg_storage[SBP_MAX_PAYLOAD_LEN]; + memset(test_msg_storage, 0, sizeof(test_msg_storage)); + u8 test_msg_len = 0; + msg_ssr_flag_iono_grid_point_sat_los_t *test_msg = + (msg_ssr_flag_iono_grid_point_sat_los_t *)test_msg_storage; + test_msg_len = sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[7] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[8] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[9] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[10] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[11] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[12] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[13] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[14] = 30; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[15] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[16] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[17] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[18] = 11; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[19] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[20] = 14; + sbp_payload_send(&sbp_state, 3025, 66, test_msg_len, test_msg_storage, + &dummy_write); + + ck_assert_msg( + test_msg_len == sizeof(encoded_frame) - 8, + "Test message has not been generated correctly, or the encoded frame " + "from the spec is badly defined. Check your test spec"); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff"); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_msg.len == sizeof(encoded_frame) - 8, + "msg_callback: len decoded incorrectly"); + ck_assert_msg( + memcmp(last_msg.msg, encoded_frame + 6, sizeof(encoded_frame) - 8) == 0, + "msg_callback: test data decoded incorrectly"); + ck_assert_msg(last_msg.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + ck_assert_msg(last_frame.n_callbacks_logged == 1, + "frame_callback: one callback should have been logged"); + ck_assert_msg(last_frame.sender_id == 66, + "frame_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_frame.msg_type == 3025, + "frame_callback: msg_type decoded incorrectly"); + ck_assert_msg(last_frame.msg_len == sizeof(encoded_frame) - 8, + "frame_callback: msg_len decoded incorrectly"); + ck_assert_msg(memcmp(last_frame.msg, encoded_frame + 6, + sizeof(encoded_frame) - 8) == 0, + "frame_callback: test data decoded incorrectly"); + ck_assert_msg(last_frame.frame_len == sizeof(encoded_frame), + "frame_callback: frame_len decoded incorrectly"); + ck_assert_msg( + memcmp(last_frame.frame, encoded_frame, sizeof(encoded_frame)) == 0, + "frame_callback: frame decoded incorrectly"); + ck_assert_msg(last_frame.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + // Cast to expected message type - the +6 byte offset is where the payload + // starts + msg_ssr_flag_iono_grid_point_sat_los_t *check_msg = + (msg_ssr_flag_iono_grid_point_sat_los_t *)((void *)last_msg.msg); + // Run tests against fields + ck_assert_msg(check_msg != 0, "stub to prevent warnings if msg isn't used"); + ck_assert_msg(check_msg->stub[0] == 180, + "incorrect value for stub[0], expected 180, is %d", + check_msg->stub[0]); + ck_assert_msg(check_msg->stub[1] == 0, + "incorrect value for stub[1], expected 0, is %d", + check_msg->stub[1]); + ck_assert_msg(check_msg->stub[2] == 0, + "incorrect value for stub[2], expected 0, is %d", + check_msg->stub[2]); + ck_assert_msg(check_msg->stub[3] == 0, + "incorrect value for stub[3], expected 0, is %d", + check_msg->stub[3]); + ck_assert_msg(check_msg->stub[4] == 3, + "incorrect value for stub[4], expected 3, is %d", + check_msg->stub[4]); + ck_assert_msg(check_msg->stub[5] == 0, + "incorrect value for stub[5], expected 0, is %d", + check_msg->stub[5]); + ck_assert_msg(check_msg->stub[6] == 1, + "incorrect value for stub[6], expected 1, is %d", + check_msg->stub[6]); + ck_assert_msg(check_msg->stub[7] == 2, + "incorrect value for stub[7], expected 2, is %d", + check_msg->stub[7]); + ck_assert_msg(check_msg->stub[8] == 3, + "incorrect value for stub[8], expected 3, is %d", + check_msg->stub[8]); + ck_assert_msg(check_msg->stub[9] == 4, + "incorrect value for stub[9], expected 4, is %d", + check_msg->stub[9]); + ck_assert_msg(check_msg->stub[10] == 0, + "incorrect value for stub[10], expected 0, is %d", + check_msg->stub[10]); + ck_assert_msg(check_msg->stub[11] == 5, + "incorrect value for stub[11], expected 5, is %d", + check_msg->stub[11]); + ck_assert_msg(check_msg->stub[12] == 0, + "incorrect value for stub[12], expected 0, is %d", + check_msg->stub[12]); + ck_assert_msg(check_msg->stub[13] == 6, + "incorrect value for stub[13], expected 6, is %d", + check_msg->stub[13]); + ck_assert_msg(check_msg->stub[14] == 30, + "incorrect value for stub[14], expected 30, is %d", + check_msg->stub[14]); + ck_assert_msg(check_msg->stub[15] == 0, + "incorrect value for stub[15], expected 0, is %d", + check_msg->stub[15]); + ck_assert_msg(check_msg->stub[16] == 2, + "incorrect value for stub[16], expected 2, is %d", + check_msg->stub[16]); + ck_assert_msg(check_msg->stub[17] == 10, + "incorrect value for stub[17], expected 10, is %d", + check_msg->stub[17]); + ck_assert_msg(check_msg->stub[18] == 11, + "incorrect value for stub[18], expected 11, is %d", + check_msg->stub[18]); + ck_assert_msg(check_msg->stub[19] == 15, + "incorrect value for stub[19], expected 15, is %d", + check_msg->stub[19]); + ck_assert_msg(check_msg->stub[20] == 14, + "incorrect value for stub[20], expected 14, is %d", + check_msg->stub[20]); + } +} +END_TEST + +Suite *legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos_suite( + void) { + Suite *s = suite_create( + "SBP generated test suite: " + "legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos"); + TCase *tc_acq = tcase_create( + "Automated_Suite_legacy_auto_check_sbp_integrity_" + "MsgSsrFlagIonoGridPointSatLos"); + tcase_add_test( + tc_acq, + test_legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints.c b/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints.c new file mode 100644 index 0000000000..535e902584 --- /dev/null +++ b/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints.c @@ -0,0 +1,375 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPoints.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u8 len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + void *context; +} last_msg; + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u16 msg_type; + u8 msg_len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + u16 frame_len; + u8 frame[SBP_MAX_FRAME_LEN]; + void *context; +} last_frame; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static int DUMMY_MEMORY_FOR_CALLBACKS = 0xdeadbeef; +static int DUMMY_MEMORY_FOR_IO = 0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return real_n; +} + +static void logging_reset() { + memset(&last_msg, 0, sizeof(last_msg)); + memset(&last_frame, 0, sizeof(last_frame)); +} + +static void msg_callback(u16 sender_id, u8 len, u8 msg[], void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.len = len; + last_msg.context = context; + memcpy(last_msg.msg, msg, len); +} + +static void frame_callback(u16 sender_id, u16 msg_type, u8 msg_len, u8 msg[], + u16 frame_len, u8 frame[], void *context) { + last_frame.n_callbacks_logged++; + last_frame.sender_id = sender_id; + last_frame.msg_type = msg_type; + last_frame.msg_len = msg_len; + memcpy(last_frame.msg, msg, msg_len); + last_frame.frame_len = frame_len; + memcpy(last_frame.frame, frame, frame_len); + last_frame.context = context; +} + +START_TEST(test_legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints) { + static sbp_msg_callbacks_node_t n; + static sbp_msg_callbacks_node_t n2; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_payload_callback_register(&sbp_state, 3015, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + sbp_frame_callback_register(&sbp_state, 3015, &frame_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n2); + + u8 encoded_frame[] = { + 85, 199, 11, 66, 0, 21, 180, 0, 0, 0, 3, 0, 1, 2, 3, + 4, 0, 5, 0, 6, 3, 10, 0, 11, 0, 12, 0, 53, 7, + }; + + dummy_reset(); + + u8 test_msg_storage[SBP_MAX_PAYLOAD_LEN]; + memset(test_msg_storage, 0, sizeof(test_msg_storage)); + u8 test_msg_len = 0; + msg_ssr_flag_iono_grid_points_t *test_msg = + (msg_ssr_flag_iono_grid_points_t *)test_msg_storage; + test_msg_len = sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[7] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[8] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[9] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[10] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[11] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[12] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[13] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[14] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[15] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[16] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[17] = 11; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[18] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[19] = 12; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[20] = 0; + sbp_payload_send(&sbp_state, 3015, 66, test_msg_len, test_msg_storage, + &dummy_write); + + ck_assert_msg( + test_msg_len == sizeof(encoded_frame) - 8, + "Test message has not been generated correctly, or the encoded frame " + "from the spec is badly defined. Check your test spec"); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff"); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_msg.len == sizeof(encoded_frame) - 8, + "msg_callback: len decoded incorrectly"); + ck_assert_msg( + memcmp(last_msg.msg, encoded_frame + 6, sizeof(encoded_frame) - 8) == 0, + "msg_callback: test data decoded incorrectly"); + ck_assert_msg(last_msg.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + ck_assert_msg(last_frame.n_callbacks_logged == 1, + "frame_callback: one callback should have been logged"); + ck_assert_msg(last_frame.sender_id == 66, + "frame_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_frame.msg_type == 3015, + "frame_callback: msg_type decoded incorrectly"); + ck_assert_msg(last_frame.msg_len == sizeof(encoded_frame) - 8, + "frame_callback: msg_len decoded incorrectly"); + ck_assert_msg(memcmp(last_frame.msg, encoded_frame + 6, + sizeof(encoded_frame) - 8) == 0, + "frame_callback: test data decoded incorrectly"); + ck_assert_msg(last_frame.frame_len == sizeof(encoded_frame), + "frame_callback: frame_len decoded incorrectly"); + ck_assert_msg( + memcmp(last_frame.frame, encoded_frame, sizeof(encoded_frame)) == 0, + "frame_callback: frame decoded incorrectly"); + ck_assert_msg(last_frame.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + // Cast to expected message type - the +6 byte offset is where the payload + // starts + msg_ssr_flag_iono_grid_points_t *check_msg = + (msg_ssr_flag_iono_grid_points_t *)((void *)last_msg.msg); + // Run tests against fields + ck_assert_msg(check_msg != 0, "stub to prevent warnings if msg isn't used"); + ck_assert_msg(check_msg->stub[0] == 180, + "incorrect value for stub[0], expected 180, is %d", + check_msg->stub[0]); + ck_assert_msg(check_msg->stub[1] == 0, + "incorrect value for stub[1], expected 0, is %d", + check_msg->stub[1]); + ck_assert_msg(check_msg->stub[2] == 0, + "incorrect value for stub[2], expected 0, is %d", + check_msg->stub[2]); + ck_assert_msg(check_msg->stub[3] == 0, + "incorrect value for stub[3], expected 0, is %d", + check_msg->stub[3]); + ck_assert_msg(check_msg->stub[4] == 3, + "incorrect value for stub[4], expected 3, is %d", + check_msg->stub[4]); + ck_assert_msg(check_msg->stub[5] == 0, + "incorrect value for stub[5], expected 0, is %d", + check_msg->stub[5]); + ck_assert_msg(check_msg->stub[6] == 1, + "incorrect value for stub[6], expected 1, is %d", + check_msg->stub[6]); + ck_assert_msg(check_msg->stub[7] == 2, + "incorrect value for stub[7], expected 2, is %d", + check_msg->stub[7]); + ck_assert_msg(check_msg->stub[8] == 3, + "incorrect value for stub[8], expected 3, is %d", + check_msg->stub[8]); + ck_assert_msg(check_msg->stub[9] == 4, + "incorrect value for stub[9], expected 4, is %d", + check_msg->stub[9]); + ck_assert_msg(check_msg->stub[10] == 0, + "incorrect value for stub[10], expected 0, is %d", + check_msg->stub[10]); + ck_assert_msg(check_msg->stub[11] == 5, + "incorrect value for stub[11], expected 5, is %d", + check_msg->stub[11]); + ck_assert_msg(check_msg->stub[12] == 0, + "incorrect value for stub[12], expected 0, is %d", + check_msg->stub[12]); + ck_assert_msg(check_msg->stub[13] == 6, + "incorrect value for stub[13], expected 6, is %d", + check_msg->stub[13]); + ck_assert_msg(check_msg->stub[14] == 3, + "incorrect value for stub[14], expected 3, is %d", + check_msg->stub[14]); + ck_assert_msg(check_msg->stub[15] == 10, + "incorrect value for stub[15], expected 10, is %d", + check_msg->stub[15]); + ck_assert_msg(check_msg->stub[16] == 0, + "incorrect value for stub[16], expected 0, is %d", + check_msg->stub[16]); + ck_assert_msg(check_msg->stub[17] == 11, + "incorrect value for stub[17], expected 11, is %d", + check_msg->stub[17]); + ck_assert_msg(check_msg->stub[18] == 0, + "incorrect value for stub[18], expected 0, is %d", + check_msg->stub[18]); + ck_assert_msg(check_msg->stub[19] == 12, + "incorrect value for stub[19], expected 12, is %d", + check_msg->stub[19]); + ck_assert_msg(check_msg->stub[20] == 0, + "incorrect value for stub[20], expected 0, is %d", + check_msg->stub[20]); + } +} +END_TEST + +Suite *legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints"); + TCase *tc_acq = tcase_create( + "Automated_Suite_legacy_auto_check_sbp_integrity_" + "MsgSsrFlagIonoGridPoints"); + tcase_add_test(tc_acq, + test_legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos.c b/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos.c new file mode 100644 index 0000000000..bcc8f85291 --- /dev/null +++ b/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos.c @@ -0,0 +1,359 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoTileSatLos.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u8 len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + void *context; +} last_msg; + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u16 msg_type; + u8 msg_len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + u16 frame_len; + u8 frame[SBP_MAX_FRAME_LEN]; + void *context; +} last_frame; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static int DUMMY_MEMORY_FOR_CALLBACKS = 0xdeadbeef; +static int DUMMY_MEMORY_FOR_IO = 0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return real_n; +} + +static void logging_reset() { + memset(&last_msg, 0, sizeof(last_msg)); + memset(&last_frame, 0, sizeof(last_frame)); +} + +static void msg_callback(u16 sender_id, u8 len, u8 msg[], void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.len = len; + last_msg.context = context; + memcpy(last_msg.msg, msg, len); +} + +static void frame_callback(u16 sender_id, u16 msg_type, u8 msg_len, u8 msg[], + u16 frame_len, u8 frame[], void *context) { + last_frame.n_callbacks_logged++; + last_frame.sender_id = sender_id; + last_frame.msg_type = msg_type; + last_frame.msg_len = msg_len; + memcpy(last_frame.msg, msg, msg_len); + last_frame.frame_len = frame_len; + memcpy(last_frame.frame, frame, frame_len); + last_frame.context = context; +} + +START_TEST(test_legacy_auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos) { + static sbp_msg_callbacks_node_t n; + static sbp_msg_callbacks_node_t n2; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_payload_callback_register(&sbp_state, 3021, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + sbp_frame_callback_register(&sbp_state, 3021, &frame_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n2); + + u8 encoded_frame[] = { + 85, 205, 11, 66, 0, 19, 180, 0, 0, 0, 3, 0, 1, 2, + 3, 4, 0, 5, 0, 6, 2, 10, 11, 15, 14, 239, 235, + }; + + dummy_reset(); + + u8 test_msg_storage[SBP_MAX_PAYLOAD_LEN]; + memset(test_msg_storage, 0, sizeof(test_msg_storage)); + u8 test_msg_len = 0; + msg_ssr_flag_iono_tile_sat_los_t *test_msg = + (msg_ssr_flag_iono_tile_sat_los_t *)test_msg_storage; + test_msg_len = sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[7] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[8] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[9] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[10] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[11] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[12] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[13] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[14] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[15] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[16] = 11; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[17] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[18] = 14; + sbp_payload_send(&sbp_state, 3021, 66, test_msg_len, test_msg_storage, + &dummy_write); + + ck_assert_msg( + test_msg_len == sizeof(encoded_frame) - 8, + "Test message has not been generated correctly, or the encoded frame " + "from the spec is badly defined. Check your test spec"); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff"); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_msg.len == sizeof(encoded_frame) - 8, + "msg_callback: len decoded incorrectly"); + ck_assert_msg( + memcmp(last_msg.msg, encoded_frame + 6, sizeof(encoded_frame) - 8) == 0, + "msg_callback: test data decoded incorrectly"); + ck_assert_msg(last_msg.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + ck_assert_msg(last_frame.n_callbacks_logged == 1, + "frame_callback: one callback should have been logged"); + ck_assert_msg(last_frame.sender_id == 66, + "frame_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_frame.msg_type == 3021, + "frame_callback: msg_type decoded incorrectly"); + ck_assert_msg(last_frame.msg_len == sizeof(encoded_frame) - 8, + "frame_callback: msg_len decoded incorrectly"); + ck_assert_msg(memcmp(last_frame.msg, encoded_frame + 6, + sizeof(encoded_frame) - 8) == 0, + "frame_callback: test data decoded incorrectly"); + ck_assert_msg(last_frame.frame_len == sizeof(encoded_frame), + "frame_callback: frame_len decoded incorrectly"); + ck_assert_msg( + memcmp(last_frame.frame, encoded_frame, sizeof(encoded_frame)) == 0, + "frame_callback: frame decoded incorrectly"); + ck_assert_msg(last_frame.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + // Cast to expected message type - the +6 byte offset is where the payload + // starts + msg_ssr_flag_iono_tile_sat_los_t *check_msg = + (msg_ssr_flag_iono_tile_sat_los_t *)((void *)last_msg.msg); + // Run tests against fields + ck_assert_msg(check_msg != 0, "stub to prevent warnings if msg isn't used"); + ck_assert_msg(check_msg->stub[0] == 180, + "incorrect value for stub[0], expected 180, is %d", + check_msg->stub[0]); + ck_assert_msg(check_msg->stub[1] == 0, + "incorrect value for stub[1], expected 0, is %d", + check_msg->stub[1]); + ck_assert_msg(check_msg->stub[2] == 0, + "incorrect value for stub[2], expected 0, is %d", + check_msg->stub[2]); + ck_assert_msg(check_msg->stub[3] == 0, + "incorrect value for stub[3], expected 0, is %d", + check_msg->stub[3]); + ck_assert_msg(check_msg->stub[4] == 3, + "incorrect value for stub[4], expected 3, is %d", + check_msg->stub[4]); + ck_assert_msg(check_msg->stub[5] == 0, + "incorrect value for stub[5], expected 0, is %d", + check_msg->stub[5]); + ck_assert_msg(check_msg->stub[6] == 1, + "incorrect value for stub[6], expected 1, is %d", + check_msg->stub[6]); + ck_assert_msg(check_msg->stub[7] == 2, + "incorrect value for stub[7], expected 2, is %d", + check_msg->stub[7]); + ck_assert_msg(check_msg->stub[8] == 3, + "incorrect value for stub[8], expected 3, is %d", + check_msg->stub[8]); + ck_assert_msg(check_msg->stub[9] == 4, + "incorrect value for stub[9], expected 4, is %d", + check_msg->stub[9]); + ck_assert_msg(check_msg->stub[10] == 0, + "incorrect value for stub[10], expected 0, is %d", + check_msg->stub[10]); + ck_assert_msg(check_msg->stub[11] == 5, + "incorrect value for stub[11], expected 5, is %d", + check_msg->stub[11]); + ck_assert_msg(check_msg->stub[12] == 0, + "incorrect value for stub[12], expected 0, is %d", + check_msg->stub[12]); + ck_assert_msg(check_msg->stub[13] == 6, + "incorrect value for stub[13], expected 6, is %d", + check_msg->stub[13]); + ck_assert_msg(check_msg->stub[14] == 2, + "incorrect value for stub[14], expected 2, is %d", + check_msg->stub[14]); + ck_assert_msg(check_msg->stub[15] == 10, + "incorrect value for stub[15], expected 10, is %d", + check_msg->stub[15]); + ck_assert_msg(check_msg->stub[16] == 11, + "incorrect value for stub[16], expected 11, is %d", + check_msg->stub[16]); + ck_assert_msg(check_msg->stub[17] == 15, + "incorrect value for stub[17], expected 15, is %d", + check_msg->stub[17]); + ck_assert_msg(check_msg->stub[18] == 14, + "incorrect value for stub[18], expected 14, is %d", + check_msg->stub[18]); + } +} +END_TEST + +Suite *legacy_auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "legacy_auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos"); + TCase *tc_acq = tcase_create( + "Automated_Suite_legacy_auto_check_sbp_integrity_" + "MsgSsrFlagIonoTileSatLos"); + tcase_add_test(tc_acq, + test_legacy_auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagSatellites.c b/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagSatellites.c new file mode 100644 index 0000000000..aa96c0fe3c --- /dev/null +++ b/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagSatellites.c @@ -0,0 +1,326 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagSatellites.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u8 len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + void *context; +} last_msg; + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u16 msg_type; + u8 msg_len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + u16 frame_len; + u8 frame[SBP_MAX_FRAME_LEN]; + void *context; +} last_frame; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static int DUMMY_MEMORY_FOR_CALLBACKS = 0xdeadbeef; +static int DUMMY_MEMORY_FOR_IO = 0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return real_n; +} + +static void logging_reset() { + memset(&last_msg, 0, sizeof(last_msg)); + memset(&last_frame, 0, sizeof(last_frame)); +} + +static void msg_callback(u16 sender_id, u8 len, u8 msg[], void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.len = len; + last_msg.context = context; + memcpy(last_msg.msg, msg, len); +} + +static void frame_callback(u16 sender_id, u16 msg_type, u8 msg_len, u8 msg[], + u16 frame_len, u8 frame[], void *context) { + last_frame.n_callbacks_logged++; + last_frame.sender_id = sender_id; + last_frame.msg_type = msg_type; + last_frame.msg_len = msg_len; + memcpy(last_frame.msg, msg, msg_len); + last_frame.frame_len = frame_len; + memcpy(last_frame.frame, frame, frame_len); + last_frame.context = context; +} + +START_TEST(test_legacy_auto_check_sbp_integrity_MsgSsrFlagSatellites) { + static sbp_msg_callbacks_node_t n; + static sbp_msg_callbacks_node_t n2; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_payload_callback_register(&sbp_state, 3005, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + sbp_frame_callback_register(&sbp_state, 3005, &frame_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n2); + + u8 encoded_frame[] = { + 85, 189, 11, 66, 0, 15, 180, 0, 0, 0, 3, 0, + 1, 2, 3, 4, 5, 3, 10, 11, 12, 110, 165, + }; + + dummy_reset(); + + u8 test_msg_storage[SBP_MAX_PAYLOAD_LEN]; + memset(test_msg_storage, 0, sizeof(test_msg_storage)); + u8 test_msg_len = 0; + msg_ssr_flag_satellites_t *test_msg = + (msg_ssr_flag_satellites_t *)test_msg_storage; + test_msg_len = sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[7] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[8] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[9] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[10] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[11] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[12] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[13] = 11; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[14] = 12; + sbp_payload_send(&sbp_state, 3005, 66, test_msg_len, test_msg_storage, + &dummy_write); + + ck_assert_msg( + test_msg_len == sizeof(encoded_frame) - 8, + "Test message has not been generated correctly, or the encoded frame " + "from the spec is badly defined. Check your test spec"); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff"); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_msg.len == sizeof(encoded_frame) - 8, + "msg_callback: len decoded incorrectly"); + ck_assert_msg( + memcmp(last_msg.msg, encoded_frame + 6, sizeof(encoded_frame) - 8) == 0, + "msg_callback: test data decoded incorrectly"); + ck_assert_msg(last_msg.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + ck_assert_msg(last_frame.n_callbacks_logged == 1, + "frame_callback: one callback should have been logged"); + ck_assert_msg(last_frame.sender_id == 66, + "frame_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_frame.msg_type == 3005, + "frame_callback: msg_type decoded incorrectly"); + ck_assert_msg(last_frame.msg_len == sizeof(encoded_frame) - 8, + "frame_callback: msg_len decoded incorrectly"); + ck_assert_msg(memcmp(last_frame.msg, encoded_frame + 6, + sizeof(encoded_frame) - 8) == 0, + "frame_callback: test data decoded incorrectly"); + ck_assert_msg(last_frame.frame_len == sizeof(encoded_frame), + "frame_callback: frame_len decoded incorrectly"); + ck_assert_msg( + memcmp(last_frame.frame, encoded_frame, sizeof(encoded_frame)) == 0, + "frame_callback: frame decoded incorrectly"); + ck_assert_msg(last_frame.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + // Cast to expected message type - the +6 byte offset is where the payload + // starts + msg_ssr_flag_satellites_t *check_msg = + (msg_ssr_flag_satellites_t *)((void *)last_msg.msg); + // Run tests against fields + ck_assert_msg(check_msg != 0, "stub to prevent warnings if msg isn't used"); + ck_assert_msg(check_msg->stub[0] == 180, + "incorrect value for stub[0], expected 180, is %d", + check_msg->stub[0]); + ck_assert_msg(check_msg->stub[1] == 0, + "incorrect value for stub[1], expected 0, is %d", + check_msg->stub[1]); + ck_assert_msg(check_msg->stub[2] == 0, + "incorrect value for stub[2], expected 0, is %d", + check_msg->stub[2]); + ck_assert_msg(check_msg->stub[3] == 0, + "incorrect value for stub[3], expected 0, is %d", + check_msg->stub[3]); + ck_assert_msg(check_msg->stub[4] == 3, + "incorrect value for stub[4], expected 3, is %d", + check_msg->stub[4]); + ck_assert_msg(check_msg->stub[5] == 0, + "incorrect value for stub[5], expected 0, is %d", + check_msg->stub[5]); + ck_assert_msg(check_msg->stub[6] == 1, + "incorrect value for stub[6], expected 1, is %d", + check_msg->stub[6]); + ck_assert_msg(check_msg->stub[7] == 2, + "incorrect value for stub[7], expected 2, is %d", + check_msg->stub[7]); + ck_assert_msg(check_msg->stub[8] == 3, + "incorrect value for stub[8], expected 3, is %d", + check_msg->stub[8]); + ck_assert_msg(check_msg->stub[9] == 4, + "incorrect value for stub[9], expected 4, is %d", + check_msg->stub[9]); + ck_assert_msg(check_msg->stub[10] == 5, + "incorrect value for stub[10], expected 5, is %d", + check_msg->stub[10]); + ck_assert_msg(check_msg->stub[11] == 3, + "incorrect value for stub[11], expected 3, is %d", + check_msg->stub[11]); + ck_assert_msg(check_msg->stub[12] == 10, + "incorrect value for stub[12], expected 10, is %d", + check_msg->stub[12]); + ck_assert_msg(check_msg->stub[13] == 11, + "incorrect value for stub[13], expected 11, is %d", + check_msg->stub[13]); + ck_assert_msg(check_msg->stub[14] == 12, + "incorrect value for stub[14], expected 12, is %d", + check_msg->stub[14]); + } +} +END_TEST + +Suite *legacy_auto_check_sbp_integrity_MsgSsrFlagSatellites_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "legacy_auto_check_sbp_integrity_MsgSsrFlagSatellites"); + TCase *tc_acq = tcase_create( + "Automated_Suite_legacy_auto_check_sbp_integrity_MsgSsrFlagSatellites"); + tcase_add_test(tc_acq, + test_legacy_auto_check_sbp_integrity_MsgSsrFlagSatellites); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints.c b/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints.c new file mode 100644 index 0000000000..e32977679e --- /dev/null +++ b/c/test/legacy/auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints.c @@ -0,0 +1,375 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagTropoGridPoints.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u8 len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + void *context; +} last_msg; + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u16 msg_type; + u8 msg_len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + u16 frame_len; + u8 frame[SBP_MAX_FRAME_LEN]; + void *context; +} last_frame; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static int DUMMY_MEMORY_FOR_CALLBACKS = 0xdeadbeef; +static int DUMMY_MEMORY_FOR_IO = 0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return real_n; +} + +static void logging_reset() { + memset(&last_msg, 0, sizeof(last_msg)); + memset(&last_frame, 0, sizeof(last_frame)); +} + +static void msg_callback(u16 sender_id, u8 len, u8 msg[], void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.len = len; + last_msg.context = context; + memcpy(last_msg.msg, msg, len); +} + +static void frame_callback(u16 sender_id, u16 msg_type, u8 msg_len, u8 msg[], + u16 frame_len, u8 frame[], void *context) { + last_frame.n_callbacks_logged++; + last_frame.sender_id = sender_id; + last_frame.msg_type = msg_type; + last_frame.msg_len = msg_len; + memcpy(last_frame.msg, msg, msg_len); + last_frame.frame_len = frame_len; + memcpy(last_frame.frame, frame, frame_len); + last_frame.context = context; +} + +START_TEST(test_legacy_auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints) { + static sbp_msg_callbacks_node_t n; + static sbp_msg_callbacks_node_t n2; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_payload_callback_register(&sbp_state, 3011, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + sbp_frame_callback_register(&sbp_state, 3011, &frame_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n2); + + u8 encoded_frame[] = { + 85, 195, 11, 66, 0, 21, 180, 0, 0, 0, 3, 0, 1, 2, 3, + 4, 0, 5, 0, 6, 3, 10, 0, 11, 0, 12, 0, 243, 150, + }; + + dummy_reset(); + + u8 test_msg_storage[SBP_MAX_PAYLOAD_LEN]; + memset(test_msg_storage, 0, sizeof(test_msg_storage)); + u8 test_msg_len = 0; + msg_ssr_flag_tropo_grid_points_t *test_msg = + (msg_ssr_flag_tropo_grid_points_t *)test_msg_storage; + test_msg_len = sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[7] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[8] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[9] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[10] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[11] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[12] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[13] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[14] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[15] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[16] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[17] = 11; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[18] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[19] = 12; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[20] = 0; + sbp_payload_send(&sbp_state, 3011, 66, test_msg_len, test_msg_storage, + &dummy_write); + + ck_assert_msg( + test_msg_len == sizeof(encoded_frame) - 8, + "Test message has not been generated correctly, or the encoded frame " + "from the spec is badly defined. Check your test spec"); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff"); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_msg.len == sizeof(encoded_frame) - 8, + "msg_callback: len decoded incorrectly"); + ck_assert_msg( + memcmp(last_msg.msg, encoded_frame + 6, sizeof(encoded_frame) - 8) == 0, + "msg_callback: test data decoded incorrectly"); + ck_assert_msg(last_msg.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + ck_assert_msg(last_frame.n_callbacks_logged == 1, + "frame_callback: one callback should have been logged"); + ck_assert_msg(last_frame.sender_id == 66, + "frame_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_frame.msg_type == 3011, + "frame_callback: msg_type decoded incorrectly"); + ck_assert_msg(last_frame.msg_len == sizeof(encoded_frame) - 8, + "frame_callback: msg_len decoded incorrectly"); + ck_assert_msg(memcmp(last_frame.msg, encoded_frame + 6, + sizeof(encoded_frame) - 8) == 0, + "frame_callback: test data decoded incorrectly"); + ck_assert_msg(last_frame.frame_len == sizeof(encoded_frame), + "frame_callback: frame_len decoded incorrectly"); + ck_assert_msg( + memcmp(last_frame.frame, encoded_frame, sizeof(encoded_frame)) == 0, + "frame_callback: frame decoded incorrectly"); + ck_assert_msg(last_frame.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + // Cast to expected message type - the +6 byte offset is where the payload + // starts + msg_ssr_flag_tropo_grid_points_t *check_msg = + (msg_ssr_flag_tropo_grid_points_t *)((void *)last_msg.msg); + // Run tests against fields + ck_assert_msg(check_msg != 0, "stub to prevent warnings if msg isn't used"); + ck_assert_msg(check_msg->stub[0] == 180, + "incorrect value for stub[0], expected 180, is %d", + check_msg->stub[0]); + ck_assert_msg(check_msg->stub[1] == 0, + "incorrect value for stub[1], expected 0, is %d", + check_msg->stub[1]); + ck_assert_msg(check_msg->stub[2] == 0, + "incorrect value for stub[2], expected 0, is %d", + check_msg->stub[2]); + ck_assert_msg(check_msg->stub[3] == 0, + "incorrect value for stub[3], expected 0, is %d", + check_msg->stub[3]); + ck_assert_msg(check_msg->stub[4] == 3, + "incorrect value for stub[4], expected 3, is %d", + check_msg->stub[4]); + ck_assert_msg(check_msg->stub[5] == 0, + "incorrect value for stub[5], expected 0, is %d", + check_msg->stub[5]); + ck_assert_msg(check_msg->stub[6] == 1, + "incorrect value for stub[6], expected 1, is %d", + check_msg->stub[6]); + ck_assert_msg(check_msg->stub[7] == 2, + "incorrect value for stub[7], expected 2, is %d", + check_msg->stub[7]); + ck_assert_msg(check_msg->stub[8] == 3, + "incorrect value for stub[8], expected 3, is %d", + check_msg->stub[8]); + ck_assert_msg(check_msg->stub[9] == 4, + "incorrect value for stub[9], expected 4, is %d", + check_msg->stub[9]); + ck_assert_msg(check_msg->stub[10] == 0, + "incorrect value for stub[10], expected 0, is %d", + check_msg->stub[10]); + ck_assert_msg(check_msg->stub[11] == 5, + "incorrect value for stub[11], expected 5, is %d", + check_msg->stub[11]); + ck_assert_msg(check_msg->stub[12] == 0, + "incorrect value for stub[12], expected 0, is %d", + check_msg->stub[12]); + ck_assert_msg(check_msg->stub[13] == 6, + "incorrect value for stub[13], expected 6, is %d", + check_msg->stub[13]); + ck_assert_msg(check_msg->stub[14] == 3, + "incorrect value for stub[14], expected 3, is %d", + check_msg->stub[14]); + ck_assert_msg(check_msg->stub[15] == 10, + "incorrect value for stub[15], expected 10, is %d", + check_msg->stub[15]); + ck_assert_msg(check_msg->stub[16] == 0, + "incorrect value for stub[16], expected 0, is %d", + check_msg->stub[16]); + ck_assert_msg(check_msg->stub[17] == 11, + "incorrect value for stub[17], expected 11, is %d", + check_msg->stub[17]); + ck_assert_msg(check_msg->stub[18] == 0, + "incorrect value for stub[18], expected 0, is %d", + check_msg->stub[18]); + ck_assert_msg(check_msg->stub[19] == 12, + "incorrect value for stub[19], expected 12, is %d", + check_msg->stub[19]); + ck_assert_msg(check_msg->stub[20] == 0, + "incorrect value for stub[20], expected 0, is %d", + check_msg->stub[20]); + } +} +END_TEST + +Suite *legacy_auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "legacy_auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints"); + TCase *tc_acq = tcase_create( + "Automated_Suite_legacy_auto_check_sbp_integrity_" + "MsgSsrFlagTropoGridPoints"); + tcase_add_test( + tc_acq, test_legacy_auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/legacy/auto_check_sbp_navigation_MsgGPSLeapSecond.c b/c/test/legacy/auto_check_sbp_navigation_MsgGPSLeapSecond.c new file mode 100644 index 0000000000..9f60a3e744 --- /dev/null +++ b/c/test/legacy/auto_check_sbp_navigation_MsgGPSLeapSecond.c @@ -0,0 +1,316 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSLeapSecond.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u8 len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + void *context; +} last_msg; + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u16 msg_type; + u8 msg_len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + u16 frame_len; + u8 frame[SBP_MAX_FRAME_LEN]; + void *context; +} last_frame; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static int DUMMY_MEMORY_FOR_CALLBACKS = 0xdeadbeef; +static int DUMMY_MEMORY_FOR_IO = 0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return real_n; +} + +static void logging_reset() { + memset(&last_msg, 0, sizeof(last_msg)); + memset(&last_frame, 0, sizeof(last_frame)); +} + +static void msg_callback(u16 sender_id, u8 len, u8 msg[], void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.len = len; + last_msg.context = context; + memcpy(last_msg.msg, msg, len); +} + +static void frame_callback(u16 sender_id, u16 msg_type, u8 msg_len, u8 msg[], + u16 frame_len, u8 frame[], void *context) { + last_frame.n_callbacks_logged++; + last_frame.sender_id = sender_id; + last_frame.msg_type = msg_type; + last_frame.msg_len = msg_len; + memcpy(last_frame.msg, msg, msg_len); + last_frame.frame_len = frame_len; + memcpy(last_frame.frame, frame, frame_len); + last_frame.context = context; +} + +START_TEST(test_legacy_auto_check_sbp_navigation_MsgGPSLeapSecond) { + static sbp_msg_callbacks_node_t n; + static sbp_msg_callbacks_node_t n2; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_payload_callback_register(&sbp_state, 570, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + sbp_frame_callback_register(&sbp_state, 570, &frame_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n2); + + u8 encoded_frame[] = { + 85, 58, 2, 66, 0, 14, 1, 0, 2, 0, 3, 4, 5, 0, 6, 0, 7, 0, 8, 9, 50, 232, + }; + + dummy_reset(); + + u8 test_msg_storage[SBP_MAX_PAYLOAD_LEN]; + memset(test_msg_storage, 0, sizeof(test_msg_storage)); + u8 test_msg_len = 0; + msg_gps_leap_second_t *test_msg = (msg_gps_leap_second_t *)test_msg_storage; + test_msg_len = sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[0] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[2] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[5] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[6] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[7] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[8] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[9] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[10] = 7; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[11] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[12] = 8; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[13] = 9; + sbp_payload_send(&sbp_state, 570, 66, test_msg_len, test_msg_storage, + &dummy_write); + + ck_assert_msg( + test_msg_len == sizeof(encoded_frame) - 8, + "Test message has not been generated correctly, or the encoded frame " + "from the spec is badly defined. Check your test spec"); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff"); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_msg.len == sizeof(encoded_frame) - 8, + "msg_callback: len decoded incorrectly"); + ck_assert_msg( + memcmp(last_msg.msg, encoded_frame + 6, sizeof(encoded_frame) - 8) == 0, + "msg_callback: test data decoded incorrectly"); + ck_assert_msg(last_msg.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + ck_assert_msg(last_frame.n_callbacks_logged == 1, + "frame_callback: one callback should have been logged"); + ck_assert_msg(last_frame.sender_id == 66, + "frame_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_frame.msg_type == 570, + "frame_callback: msg_type decoded incorrectly"); + ck_assert_msg(last_frame.msg_len == sizeof(encoded_frame) - 8, + "frame_callback: msg_len decoded incorrectly"); + ck_assert_msg(memcmp(last_frame.msg, encoded_frame + 6, + sizeof(encoded_frame) - 8) == 0, + "frame_callback: test data decoded incorrectly"); + ck_assert_msg(last_frame.frame_len == sizeof(encoded_frame), + "frame_callback: frame_len decoded incorrectly"); + ck_assert_msg( + memcmp(last_frame.frame, encoded_frame, sizeof(encoded_frame)) == 0, + "frame_callback: frame decoded incorrectly"); + ck_assert_msg(last_frame.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + // Cast to expected message type - the +6 byte offset is where the payload + // starts + msg_gps_leap_second_t *check_msg = + (msg_gps_leap_second_t *)((void *)last_msg.msg); + // Run tests against fields + ck_assert_msg(check_msg != 0, "stub to prevent warnings if msg isn't used"); + ck_assert_msg(check_msg->stub[0] == 1, + "incorrect value for stub[0], expected 1, is %d", + check_msg->stub[0]); + ck_assert_msg(check_msg->stub[1] == 0, + "incorrect value for stub[1], expected 0, is %d", + check_msg->stub[1]); + ck_assert_msg(check_msg->stub[2] == 2, + "incorrect value for stub[2], expected 2, is %d", + check_msg->stub[2]); + ck_assert_msg(check_msg->stub[3] == 0, + "incorrect value for stub[3], expected 0, is %d", + check_msg->stub[3]); + ck_assert_msg(check_msg->stub[4] == 3, + "incorrect value for stub[4], expected 3, is %d", + check_msg->stub[4]); + ck_assert_msg(check_msg->stub[5] == 4, + "incorrect value for stub[5], expected 4, is %d", + check_msg->stub[5]); + ck_assert_msg(check_msg->stub[6] == 5, + "incorrect value for stub[6], expected 5, is %d", + check_msg->stub[6]); + ck_assert_msg(check_msg->stub[7] == 0, + "incorrect value for stub[7], expected 0, is %d", + check_msg->stub[7]); + ck_assert_msg(check_msg->stub[8] == 6, + "incorrect value for stub[8], expected 6, is %d", + check_msg->stub[8]); + ck_assert_msg(check_msg->stub[9] == 0, + "incorrect value for stub[9], expected 0, is %d", + check_msg->stub[9]); + ck_assert_msg(check_msg->stub[10] == 7, + "incorrect value for stub[10], expected 7, is %d", + check_msg->stub[10]); + ck_assert_msg(check_msg->stub[11] == 0, + "incorrect value for stub[11], expected 0, is %d", + check_msg->stub[11]); + ck_assert_msg(check_msg->stub[12] == 8, + "incorrect value for stub[12], expected 8, is %d", + check_msg->stub[12]); + ck_assert_msg(check_msg->stub[13] == 9, + "incorrect value for stub[13], expected 9, is %d", + check_msg->stub[13]); + } +} +END_TEST + +Suite *legacy_auto_check_sbp_navigation_MsgGPSLeapSecond_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "legacy_auto_check_sbp_navigation_MsgGPSLeapSecond"); + TCase *tc_acq = tcase_create( + "Automated_Suite_legacy_auto_check_sbp_navigation_MsgGPSLeapSecond"); + tcase_add_test(tc_acq, + test_legacy_auto_check_sbp_navigation_MsgGPSLeapSecond); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/legacy/auto_check_sbp_navigation_MsgItrf.c b/c/test/legacy/auto_check_sbp_navigation_MsgItrf.c new file mode 100644 index 0000000000..8295213c0b --- /dev/null +++ b/c/test/legacy/auto_check_sbp_navigation_MsgItrf.c @@ -0,0 +1,1200 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml by generate.py. Do +// not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u8 len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + void *context; +} last_msg; + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u16 msg_type; + u8 msg_len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + u16 frame_len; + u8 frame[SBP_MAX_FRAME_LEN]; + void *context; +} last_frame; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static int DUMMY_MEMORY_FOR_CALLBACKS = 0xdeadbeef; +static int DUMMY_MEMORY_FOR_IO = 0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return real_n; +} + +static void logging_reset() { + memset(&last_msg, 0, sizeof(last_msg)); + memset(&last_frame, 0, sizeof(last_frame)); +} + +static void msg_callback(u16 sender_id, u8 len, u8 msg[], void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.len = len; + last_msg.context = context; + memcpy(last_msg.msg, msg, len); +} + +static void frame_callback(u16 sender_id, u16 msg_type, u8 msg_len, u8 msg[], + u16 frame_len, u8 frame[], void *context) { + last_frame.n_callbacks_logged++; + last_frame.sender_id = sender_id; + last_frame.msg_type = msg_type; + last_frame.msg_len = msg_len; + memcpy(last_frame.msg, msg, msg_len); + last_frame.frame_len = frame_len; + memcpy(last_frame.frame, frame, frame_len); + last_frame.context = context; +} + +START_TEST(test_legacy_auto_check_sbp_navigation_MsgItrf) { + static sbp_msg_callbacks_node_t n; + static sbp_msg_callbacks_node_t n2; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_payload_callback_register(&sbp_state, 580, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + sbp_frame_callback_register(&sbp_state, 580, &frame_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n2); + + u8 encoded_frame[] = { + 85, 68, 2, 66, 0, 124, 1, 2, 102, 111, 111, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 98, 97, 114, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 5, 0, 6, 0, 7, 0, 0, 0, 8, 0, 0, 0, 9, + 0, 0, 0, 10, 0, 0, 0, 11, 0, 0, 0, 12, 0, 0, 0, 13, 0, + 0, 0, 14, 0, 0, 0, 15, 0, 0, 0, 16, 0, 0, 0, 17, 0, 0, + 0, 18, 0, 0, 0, 19, 0, 0, 0, 20, 0, 66, 126, + }; + + dummy_reset(); + + u8 test_msg_storage[SBP_MAX_PAYLOAD_LEN]; + memset(test_msg_storage, 0, sizeof(test_msg_storage)); + u8 test_msg_len = 0; + msg_itrf_t *test_msg = (msg_itrf_t *)test_msg_storage; + test_msg_len = sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[0] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[1] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[2] = 102; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[3] = 111; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[4] = 111; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[6] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[7] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[8] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[9] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[10] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[11] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[12] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[13] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[14] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[15] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[16] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[17] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[18] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[19] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[20] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[21] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[22] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[23] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[24] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[25] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[26] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[27] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[28] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[29] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[30] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[31] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[32] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[33] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[34] = 98; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[35] = 97; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[36] = 114; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[37] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[38] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[39] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[40] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[41] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[42] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[43] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[44] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[45] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[46] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[47] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[48] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[49] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[50] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[51] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[52] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[53] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[54] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[55] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[56] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[57] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[58] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[59] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[60] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[61] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[62] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[63] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[64] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[65] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[66] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[67] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[68] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[69] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[70] = 7; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[71] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[72] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[73] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[74] = 8; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[75] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[76] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[77] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[78] = 9; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[79] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[80] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[81] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[82] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[83] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[84] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[85] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[86] = 11; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[87] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[88] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[89] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[90] = 12; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[91] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[92] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[93] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[94] = 13; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[95] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[96] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[97] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[98] = 14; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[99] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[100] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[101] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[102] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[103] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[104] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[105] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[106] = 16; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[107] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[108] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[109] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[110] = 17; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[111] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[112] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[113] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[114] = 18; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[115] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[116] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[117] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[118] = 19; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[119] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[120] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[121] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[122] = 20; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[123] = 0; + sbp_payload_send(&sbp_state, 580, 66, test_msg_len, test_msg_storage, + &dummy_write); + + ck_assert_msg( + test_msg_len == sizeof(encoded_frame) - 8, + "Test message has not been generated correctly, or the encoded frame " + "from the spec is badly defined. Check your test spec"); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff"); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_msg.len == sizeof(encoded_frame) - 8, + "msg_callback: len decoded incorrectly"); + ck_assert_msg( + memcmp(last_msg.msg, encoded_frame + 6, sizeof(encoded_frame) - 8) == 0, + "msg_callback: test data decoded incorrectly"); + ck_assert_msg(last_msg.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + ck_assert_msg(last_frame.n_callbacks_logged == 1, + "frame_callback: one callback should have been logged"); + ck_assert_msg(last_frame.sender_id == 66, + "frame_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_frame.msg_type == 580, + "frame_callback: msg_type decoded incorrectly"); + ck_assert_msg(last_frame.msg_len == sizeof(encoded_frame) - 8, + "frame_callback: msg_len decoded incorrectly"); + ck_assert_msg(memcmp(last_frame.msg, encoded_frame + 6, + sizeof(encoded_frame) - 8) == 0, + "frame_callback: test data decoded incorrectly"); + ck_assert_msg(last_frame.frame_len == sizeof(encoded_frame), + "frame_callback: frame_len decoded incorrectly"); + ck_assert_msg( + memcmp(last_frame.frame, encoded_frame, sizeof(encoded_frame)) == 0, + "frame_callback: frame decoded incorrectly"); + ck_assert_msg(last_frame.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + // Cast to expected message type - the +6 byte offset is where the payload + // starts + msg_itrf_t *check_msg = (msg_itrf_t *)((void *)last_msg.msg); + // Run tests against fields + ck_assert_msg(check_msg != 0, "stub to prevent warnings if msg isn't used"); + ck_assert_msg(check_msg->stub[0] == 1, + "incorrect value for stub[0], expected 1, is %d", + check_msg->stub[0]); + ck_assert_msg(check_msg->stub[1] == 2, + "incorrect value for stub[1], expected 2, is %d", + check_msg->stub[1]); + ck_assert_msg(check_msg->stub[2] == 102, + "incorrect value for stub[2], expected 102, is %d", + check_msg->stub[2]); + ck_assert_msg(check_msg->stub[3] == 111, + "incorrect value for stub[3], expected 111, is %d", + check_msg->stub[3]); + ck_assert_msg(check_msg->stub[4] == 111, + "incorrect value for stub[4], expected 111, is %d", + check_msg->stub[4]); + ck_assert_msg(check_msg->stub[5] == 0, + "incorrect value for stub[5], expected 0, is %d", + check_msg->stub[5]); + ck_assert_msg(check_msg->stub[6] == 0, + "incorrect value for stub[6], expected 0, is %d", + check_msg->stub[6]); + ck_assert_msg(check_msg->stub[7] == 0, + "incorrect value for stub[7], expected 0, is %d", + check_msg->stub[7]); + ck_assert_msg(check_msg->stub[8] == 0, + "incorrect value for stub[8], expected 0, is %d", + check_msg->stub[8]); + ck_assert_msg(check_msg->stub[9] == 0, + "incorrect value for stub[9], expected 0, is %d", + check_msg->stub[9]); + ck_assert_msg(check_msg->stub[10] == 0, + "incorrect value for stub[10], expected 0, is %d", + check_msg->stub[10]); + ck_assert_msg(check_msg->stub[11] == 0, + "incorrect value for stub[11], expected 0, is %d", + check_msg->stub[11]); + ck_assert_msg(check_msg->stub[12] == 0, + "incorrect value for stub[12], expected 0, is %d", + check_msg->stub[12]); + ck_assert_msg(check_msg->stub[13] == 0, + "incorrect value for stub[13], expected 0, is %d", + check_msg->stub[13]); + ck_assert_msg(check_msg->stub[14] == 0, + "incorrect value for stub[14], expected 0, is %d", + check_msg->stub[14]); + ck_assert_msg(check_msg->stub[15] == 0, + "incorrect value for stub[15], expected 0, is %d", + check_msg->stub[15]); + ck_assert_msg(check_msg->stub[16] == 0, + "incorrect value for stub[16], expected 0, is %d", + check_msg->stub[16]); + ck_assert_msg(check_msg->stub[17] == 0, + "incorrect value for stub[17], expected 0, is %d", + check_msg->stub[17]); + ck_assert_msg(check_msg->stub[18] == 0, + "incorrect value for stub[18], expected 0, is %d", + check_msg->stub[18]); + ck_assert_msg(check_msg->stub[19] == 0, + "incorrect value for stub[19], expected 0, is %d", + check_msg->stub[19]); + ck_assert_msg(check_msg->stub[20] == 0, + "incorrect value for stub[20], expected 0, is %d", + check_msg->stub[20]); + ck_assert_msg(check_msg->stub[21] == 0, + "incorrect value for stub[21], expected 0, is %d", + check_msg->stub[21]); + ck_assert_msg(check_msg->stub[22] == 0, + "incorrect value for stub[22], expected 0, is %d", + check_msg->stub[22]); + ck_assert_msg(check_msg->stub[23] == 0, + "incorrect value for stub[23], expected 0, is %d", + check_msg->stub[23]); + ck_assert_msg(check_msg->stub[24] == 0, + "incorrect value for stub[24], expected 0, is %d", + check_msg->stub[24]); + ck_assert_msg(check_msg->stub[25] == 0, + "incorrect value for stub[25], expected 0, is %d", + check_msg->stub[25]); + ck_assert_msg(check_msg->stub[26] == 0, + "incorrect value for stub[26], expected 0, is %d", + check_msg->stub[26]); + ck_assert_msg(check_msg->stub[27] == 0, + "incorrect value for stub[27], expected 0, is %d", + check_msg->stub[27]); + ck_assert_msg(check_msg->stub[28] == 0, + "incorrect value for stub[28], expected 0, is %d", + check_msg->stub[28]); + ck_assert_msg(check_msg->stub[29] == 0, + "incorrect value for stub[29], expected 0, is %d", + check_msg->stub[29]); + ck_assert_msg(check_msg->stub[30] == 0, + "incorrect value for stub[30], expected 0, is %d", + check_msg->stub[30]); + ck_assert_msg(check_msg->stub[31] == 0, + "incorrect value for stub[31], expected 0, is %d", + check_msg->stub[31]); + ck_assert_msg(check_msg->stub[32] == 0, + "incorrect value for stub[32], expected 0, is %d", + check_msg->stub[32]); + ck_assert_msg(check_msg->stub[33] == 3, + "incorrect value for stub[33], expected 3, is %d", + check_msg->stub[33]); + ck_assert_msg(check_msg->stub[34] == 98, + "incorrect value for stub[34], expected 98, is %d", + check_msg->stub[34]); + ck_assert_msg(check_msg->stub[35] == 97, + "incorrect value for stub[35], expected 97, is %d", + check_msg->stub[35]); + ck_assert_msg(check_msg->stub[36] == 114, + "incorrect value for stub[36], expected 114, is %d", + check_msg->stub[36]); + ck_assert_msg(check_msg->stub[37] == 0, + "incorrect value for stub[37], expected 0, is %d", + check_msg->stub[37]); + ck_assert_msg(check_msg->stub[38] == 0, + "incorrect value for stub[38], expected 0, is %d", + check_msg->stub[38]); + ck_assert_msg(check_msg->stub[39] == 0, + "incorrect value for stub[39], expected 0, is %d", + check_msg->stub[39]); + ck_assert_msg(check_msg->stub[40] == 0, + "incorrect value for stub[40], expected 0, is %d", + check_msg->stub[40]); + ck_assert_msg(check_msg->stub[41] == 0, + "incorrect value for stub[41], expected 0, is %d", + check_msg->stub[41]); + ck_assert_msg(check_msg->stub[42] == 0, + "incorrect value for stub[42], expected 0, is %d", + check_msg->stub[42]); + ck_assert_msg(check_msg->stub[43] == 0, + "incorrect value for stub[43], expected 0, is %d", + check_msg->stub[43]); + ck_assert_msg(check_msg->stub[44] == 0, + "incorrect value for stub[44], expected 0, is %d", + check_msg->stub[44]); + ck_assert_msg(check_msg->stub[45] == 0, + "incorrect value for stub[45], expected 0, is %d", + check_msg->stub[45]); + ck_assert_msg(check_msg->stub[46] == 0, + "incorrect value for stub[46], expected 0, is %d", + check_msg->stub[46]); + ck_assert_msg(check_msg->stub[47] == 0, + "incorrect value for stub[47], expected 0, is %d", + check_msg->stub[47]); + ck_assert_msg(check_msg->stub[48] == 0, + "incorrect value for stub[48], expected 0, is %d", + check_msg->stub[48]); + ck_assert_msg(check_msg->stub[49] == 0, + "incorrect value for stub[49], expected 0, is %d", + check_msg->stub[49]); + ck_assert_msg(check_msg->stub[50] == 0, + "incorrect value for stub[50], expected 0, is %d", + check_msg->stub[50]); + ck_assert_msg(check_msg->stub[51] == 0, + "incorrect value for stub[51], expected 0, is %d", + check_msg->stub[51]); + ck_assert_msg(check_msg->stub[52] == 0, + "incorrect value for stub[52], expected 0, is %d", + check_msg->stub[52]); + ck_assert_msg(check_msg->stub[53] == 0, + "incorrect value for stub[53], expected 0, is %d", + check_msg->stub[53]); + ck_assert_msg(check_msg->stub[54] == 0, + "incorrect value for stub[54], expected 0, is %d", + check_msg->stub[54]); + ck_assert_msg(check_msg->stub[55] == 0, + "incorrect value for stub[55], expected 0, is %d", + check_msg->stub[55]); + ck_assert_msg(check_msg->stub[56] == 0, + "incorrect value for stub[56], expected 0, is %d", + check_msg->stub[56]); + ck_assert_msg(check_msg->stub[57] == 0, + "incorrect value for stub[57], expected 0, is %d", + check_msg->stub[57]); + ck_assert_msg(check_msg->stub[58] == 0, + "incorrect value for stub[58], expected 0, is %d", + check_msg->stub[58]); + ck_assert_msg(check_msg->stub[59] == 0, + "incorrect value for stub[59], expected 0, is %d", + check_msg->stub[59]); + ck_assert_msg(check_msg->stub[60] == 0, + "incorrect value for stub[60], expected 0, is %d", + check_msg->stub[60]); + ck_assert_msg(check_msg->stub[61] == 0, + "incorrect value for stub[61], expected 0, is %d", + check_msg->stub[61]); + ck_assert_msg(check_msg->stub[62] == 0, + "incorrect value for stub[62], expected 0, is %d", + check_msg->stub[62]); + ck_assert_msg(check_msg->stub[63] == 0, + "incorrect value for stub[63], expected 0, is %d", + check_msg->stub[63]); + ck_assert_msg(check_msg->stub[64] == 0, + "incorrect value for stub[64], expected 0, is %d", + check_msg->stub[64]); + ck_assert_msg(check_msg->stub[65] == 4, + "incorrect value for stub[65], expected 4, is %d", + check_msg->stub[65]); + ck_assert_msg(check_msg->stub[66] == 5, + "incorrect value for stub[66], expected 5, is %d", + check_msg->stub[66]); + ck_assert_msg(check_msg->stub[67] == 0, + "incorrect value for stub[67], expected 0, is %d", + check_msg->stub[67]); + ck_assert_msg(check_msg->stub[68] == 6, + "incorrect value for stub[68], expected 6, is %d", + check_msg->stub[68]); + ck_assert_msg(check_msg->stub[69] == 0, + "incorrect value for stub[69], expected 0, is %d", + check_msg->stub[69]); + ck_assert_msg(check_msg->stub[70] == 7, + "incorrect value for stub[70], expected 7, is %d", + check_msg->stub[70]); + ck_assert_msg(check_msg->stub[71] == 0, + "incorrect value for stub[71], expected 0, is %d", + check_msg->stub[71]); + ck_assert_msg(check_msg->stub[72] == 0, + "incorrect value for stub[72], expected 0, is %d", + check_msg->stub[72]); + ck_assert_msg(check_msg->stub[73] == 0, + "incorrect value for stub[73], expected 0, is %d", + check_msg->stub[73]); + ck_assert_msg(check_msg->stub[74] == 8, + "incorrect value for stub[74], expected 8, is %d", + check_msg->stub[74]); + ck_assert_msg(check_msg->stub[75] == 0, + "incorrect value for stub[75], expected 0, is %d", + check_msg->stub[75]); + ck_assert_msg(check_msg->stub[76] == 0, + "incorrect value for stub[76], expected 0, is %d", + check_msg->stub[76]); + ck_assert_msg(check_msg->stub[77] == 0, + "incorrect value for stub[77], expected 0, is %d", + check_msg->stub[77]); + ck_assert_msg(check_msg->stub[78] == 9, + "incorrect value for stub[78], expected 9, is %d", + check_msg->stub[78]); + ck_assert_msg(check_msg->stub[79] == 0, + "incorrect value for stub[79], expected 0, is %d", + check_msg->stub[79]); + ck_assert_msg(check_msg->stub[80] == 0, + "incorrect value for stub[80], expected 0, is %d", + check_msg->stub[80]); + ck_assert_msg(check_msg->stub[81] == 0, + "incorrect value for stub[81], expected 0, is %d", + check_msg->stub[81]); + ck_assert_msg(check_msg->stub[82] == 10, + "incorrect value for stub[82], expected 10, is %d", + check_msg->stub[82]); + ck_assert_msg(check_msg->stub[83] == 0, + "incorrect value for stub[83], expected 0, is %d", + check_msg->stub[83]); + ck_assert_msg(check_msg->stub[84] == 0, + "incorrect value for stub[84], expected 0, is %d", + check_msg->stub[84]); + ck_assert_msg(check_msg->stub[85] == 0, + "incorrect value for stub[85], expected 0, is %d", + check_msg->stub[85]); + ck_assert_msg(check_msg->stub[86] == 11, + "incorrect value for stub[86], expected 11, is %d", + check_msg->stub[86]); + ck_assert_msg(check_msg->stub[87] == 0, + "incorrect value for stub[87], expected 0, is %d", + check_msg->stub[87]); + ck_assert_msg(check_msg->stub[88] == 0, + "incorrect value for stub[88], expected 0, is %d", + check_msg->stub[88]); + ck_assert_msg(check_msg->stub[89] == 0, + "incorrect value for stub[89], expected 0, is %d", + check_msg->stub[89]); + ck_assert_msg(check_msg->stub[90] == 12, + "incorrect value for stub[90], expected 12, is %d", + check_msg->stub[90]); + ck_assert_msg(check_msg->stub[91] == 0, + "incorrect value for stub[91], expected 0, is %d", + check_msg->stub[91]); + ck_assert_msg(check_msg->stub[92] == 0, + "incorrect value for stub[92], expected 0, is %d", + check_msg->stub[92]); + ck_assert_msg(check_msg->stub[93] == 0, + "incorrect value for stub[93], expected 0, is %d", + check_msg->stub[93]); + ck_assert_msg(check_msg->stub[94] == 13, + "incorrect value for stub[94], expected 13, is %d", + check_msg->stub[94]); + ck_assert_msg(check_msg->stub[95] == 0, + "incorrect value for stub[95], expected 0, is %d", + check_msg->stub[95]); + ck_assert_msg(check_msg->stub[96] == 0, + "incorrect value for stub[96], expected 0, is %d", + check_msg->stub[96]); + ck_assert_msg(check_msg->stub[97] == 0, + "incorrect value for stub[97], expected 0, is %d", + check_msg->stub[97]); + ck_assert_msg(check_msg->stub[98] == 14, + "incorrect value for stub[98], expected 14, is %d", + check_msg->stub[98]); + ck_assert_msg(check_msg->stub[99] == 0, + "incorrect value for stub[99], expected 0, is %d", + check_msg->stub[99]); + ck_assert_msg(check_msg->stub[100] == 0, + "incorrect value for stub[100], expected 0, is %d", + check_msg->stub[100]); + ck_assert_msg(check_msg->stub[101] == 0, + "incorrect value for stub[101], expected 0, is %d", + check_msg->stub[101]); + ck_assert_msg(check_msg->stub[102] == 15, + "incorrect value for stub[102], expected 15, is %d", + check_msg->stub[102]); + ck_assert_msg(check_msg->stub[103] == 0, + "incorrect value for stub[103], expected 0, is %d", + check_msg->stub[103]); + ck_assert_msg(check_msg->stub[104] == 0, + "incorrect value for stub[104], expected 0, is %d", + check_msg->stub[104]); + ck_assert_msg(check_msg->stub[105] == 0, + "incorrect value for stub[105], expected 0, is %d", + check_msg->stub[105]); + ck_assert_msg(check_msg->stub[106] == 16, + "incorrect value for stub[106], expected 16, is %d", + check_msg->stub[106]); + ck_assert_msg(check_msg->stub[107] == 0, + "incorrect value for stub[107], expected 0, is %d", + check_msg->stub[107]); + ck_assert_msg(check_msg->stub[108] == 0, + "incorrect value for stub[108], expected 0, is %d", + check_msg->stub[108]); + ck_assert_msg(check_msg->stub[109] == 0, + "incorrect value for stub[109], expected 0, is %d", + check_msg->stub[109]); + ck_assert_msg(check_msg->stub[110] == 17, + "incorrect value for stub[110], expected 17, is %d", + check_msg->stub[110]); + ck_assert_msg(check_msg->stub[111] == 0, + "incorrect value for stub[111], expected 0, is %d", + check_msg->stub[111]); + ck_assert_msg(check_msg->stub[112] == 0, + "incorrect value for stub[112], expected 0, is %d", + check_msg->stub[112]); + ck_assert_msg(check_msg->stub[113] == 0, + "incorrect value for stub[113], expected 0, is %d", + check_msg->stub[113]); + ck_assert_msg(check_msg->stub[114] == 18, + "incorrect value for stub[114], expected 18, is %d", + check_msg->stub[114]); + ck_assert_msg(check_msg->stub[115] == 0, + "incorrect value for stub[115], expected 0, is %d", + check_msg->stub[115]); + ck_assert_msg(check_msg->stub[116] == 0, + "incorrect value for stub[116], expected 0, is %d", + check_msg->stub[116]); + ck_assert_msg(check_msg->stub[117] == 0, + "incorrect value for stub[117], expected 0, is %d", + check_msg->stub[117]); + ck_assert_msg(check_msg->stub[118] == 19, + "incorrect value for stub[118], expected 19, is %d", + check_msg->stub[118]); + ck_assert_msg(check_msg->stub[119] == 0, + "incorrect value for stub[119], expected 0, is %d", + check_msg->stub[119]); + ck_assert_msg(check_msg->stub[120] == 0, + "incorrect value for stub[120], expected 0, is %d", + check_msg->stub[120]); + ck_assert_msg(check_msg->stub[121] == 0, + "incorrect value for stub[121], expected 0, is %d", + check_msg->stub[121]); + ck_assert_msg(check_msg->stub[122] == 20, + "incorrect value for stub[122], expected 20, is %d", + check_msg->stub[122]); + ck_assert_msg(check_msg->stub[123] == 0, + "incorrect value for stub[123], expected 0, is %d", + check_msg->stub[123]); + } +} +END_TEST + +Suite *legacy_auto_check_sbp_navigation_MsgItrf_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: legacy_auto_check_sbp_navigation_MsgItrf"); + TCase *tc_acq = + tcase_create("Automated_Suite_legacy_auto_check_sbp_navigation_MsgItrf"); + tcase_add_test(tc_acq, test_legacy_auto_check_sbp_navigation_MsgItrf); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/legacy/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds.c b/c/test/legacy/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds.c new file mode 100644 index 0000000000..63ea89f63c --- /dev/null +++ b/c/test/legacy/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds.c @@ -0,0 +1,455 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrCodePhaseBiasesBounds.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u8 len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + void *context; +} last_msg; + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u16 msg_type; + u8 msg_len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + u16 frame_len; + u8 frame[SBP_MAX_FRAME_LEN]; + void *context; +} last_frame; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static int DUMMY_MEMORY_FOR_CALLBACKS = 0xdeadbeef; +static int DUMMY_MEMORY_FOR_IO = 0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return real_n; +} + +static void logging_reset() { + memset(&last_msg, 0, sizeof(last_msg)); + memset(&last_frame, 0, sizeof(last_frame)); +} + +static void msg_callback(u16 sender_id, u8 len, u8 msg[], void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.len = len; + last_msg.context = context; + memcpy(last_msg.msg, msg, len); +} + +static void frame_callback(u16 sender_id, u16 msg_type, u8 msg_len, u8 msg[], + u16 frame_len, u8 frame[], void *context) { + last_frame.n_callbacks_logged++; + last_frame.sender_id = sender_id; + last_frame.msg_type = msg_type; + last_frame.msg_len = msg_len; + memcpy(last_frame.msg, msg, msg_len); + last_frame.frame_len = frame_len; + memcpy(last_frame.frame, frame, frame_len); + last_frame.context = context; +} + +START_TEST(test_legacy_auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds) { + static sbp_msg_callbacks_node_t n; + static sbp_msg_callbacks_node_t n2; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_payload_callback_register(&sbp_state, 1516, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + sbp_frame_callback_register(&sbp_state, 1516, &frame_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n2); + + u8 encoded_frame[] = { + 85, 236, 5, 66, 0, 31, 180, 0, 0, 0, 3, 0, 1, + 2, 1, 14, 15, 1, 3, 0, 3, 39, 1, 39, 1, 1, + 3, 39, 1, 39, 1, 1, 1, 39, 1, 39, 1, 23, 113, + }; + + dummy_reset(); + + u8 test_msg_storage[SBP_MAX_PAYLOAD_LEN]; + memset(test_msg_storage, 0, sizeof(test_msg_storage)); + u8 test_msg_len = 0; + msg_ssr_code_phase_biases_bounds_t *test_msg = + (msg_ssr_code_phase_biases_bounds_t *)test_msg_storage; + test_msg_len = sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[7] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[8] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[9] = 14; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[10] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[11] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[12] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[13] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[14] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[15] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[16] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[17] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[18] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[19] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[20] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[21] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[22] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[23] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[24] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[25] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[26] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[27] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[28] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[29] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[30] = 1; + sbp_payload_send(&sbp_state, 1516, 66, test_msg_len, test_msg_storage, + &dummy_write); + + ck_assert_msg( + test_msg_len == sizeof(encoded_frame) - 8, + "Test message has not been generated correctly, or the encoded frame " + "from the spec is badly defined. Check your test spec"); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff"); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_msg.len == sizeof(encoded_frame) - 8, + "msg_callback: len decoded incorrectly"); + ck_assert_msg( + memcmp(last_msg.msg, encoded_frame + 6, sizeof(encoded_frame) - 8) == 0, + "msg_callback: test data decoded incorrectly"); + ck_assert_msg(last_msg.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + ck_assert_msg(last_frame.n_callbacks_logged == 1, + "frame_callback: one callback should have been logged"); + ck_assert_msg(last_frame.sender_id == 66, + "frame_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_frame.msg_type == 1516, + "frame_callback: msg_type decoded incorrectly"); + ck_assert_msg(last_frame.msg_len == sizeof(encoded_frame) - 8, + "frame_callback: msg_len decoded incorrectly"); + ck_assert_msg(memcmp(last_frame.msg, encoded_frame + 6, + sizeof(encoded_frame) - 8) == 0, + "frame_callback: test data decoded incorrectly"); + ck_assert_msg(last_frame.frame_len == sizeof(encoded_frame), + "frame_callback: frame_len decoded incorrectly"); + ck_assert_msg( + memcmp(last_frame.frame, encoded_frame, sizeof(encoded_frame)) == 0, + "frame_callback: frame decoded incorrectly"); + ck_assert_msg(last_frame.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + // Cast to expected message type - the +6 byte offset is where the payload + // starts + msg_ssr_code_phase_biases_bounds_t *check_msg = + (msg_ssr_code_phase_biases_bounds_t *)((void *)last_msg.msg); + // Run tests against fields + ck_assert_msg(check_msg != 0, "stub to prevent warnings if msg isn't used"); + ck_assert_msg(check_msg->stub[0] == 180, + "incorrect value for stub[0], expected 180, is %d", + check_msg->stub[0]); + ck_assert_msg(check_msg->stub[1] == 0, + "incorrect value for stub[1], expected 0, is %d", + check_msg->stub[1]); + ck_assert_msg(check_msg->stub[2] == 0, + "incorrect value for stub[2], expected 0, is %d", + check_msg->stub[2]); + ck_assert_msg(check_msg->stub[3] == 0, + "incorrect value for stub[3], expected 0, is %d", + check_msg->stub[3]); + ck_assert_msg(check_msg->stub[4] == 3, + "incorrect value for stub[4], expected 3, is %d", + check_msg->stub[4]); + ck_assert_msg(check_msg->stub[5] == 0, + "incorrect value for stub[5], expected 0, is %d", + check_msg->stub[5]); + ck_assert_msg(check_msg->stub[6] == 1, + "incorrect value for stub[6], expected 1, is %d", + check_msg->stub[6]); + ck_assert_msg(check_msg->stub[7] == 2, + "incorrect value for stub[7], expected 2, is %d", + check_msg->stub[7]); + ck_assert_msg(check_msg->stub[8] == 1, + "incorrect value for stub[8], expected 1, is %d", + check_msg->stub[8]); + ck_assert_msg(check_msg->stub[9] == 14, + "incorrect value for stub[9], expected 14, is %d", + check_msg->stub[9]); + ck_assert_msg(check_msg->stub[10] == 15, + "incorrect value for stub[10], expected 15, is %d", + check_msg->stub[10]); + ck_assert_msg(check_msg->stub[11] == 1, + "incorrect value for stub[11], expected 1, is %d", + check_msg->stub[11]); + ck_assert_msg(check_msg->stub[12] == 3, + "incorrect value for stub[12], expected 3, is %d", + check_msg->stub[12]); + ck_assert_msg(check_msg->stub[13] == 0, + "incorrect value for stub[13], expected 0, is %d", + check_msg->stub[13]); + ck_assert_msg(check_msg->stub[14] == 3, + "incorrect value for stub[14], expected 3, is %d", + check_msg->stub[14]); + ck_assert_msg(check_msg->stub[15] == 39, + "incorrect value for stub[15], expected 39, is %d", + check_msg->stub[15]); + ck_assert_msg(check_msg->stub[16] == 1, + "incorrect value for stub[16], expected 1, is %d", + check_msg->stub[16]); + ck_assert_msg(check_msg->stub[17] == 39, + "incorrect value for stub[17], expected 39, is %d", + check_msg->stub[17]); + ck_assert_msg(check_msg->stub[18] == 1, + "incorrect value for stub[18], expected 1, is %d", + check_msg->stub[18]); + ck_assert_msg(check_msg->stub[19] == 1, + "incorrect value for stub[19], expected 1, is %d", + check_msg->stub[19]); + ck_assert_msg(check_msg->stub[20] == 3, + "incorrect value for stub[20], expected 3, is %d", + check_msg->stub[20]); + ck_assert_msg(check_msg->stub[21] == 39, + "incorrect value for stub[21], expected 39, is %d", + check_msg->stub[21]); + ck_assert_msg(check_msg->stub[22] == 1, + "incorrect value for stub[22], expected 1, is %d", + check_msg->stub[22]); + ck_assert_msg(check_msg->stub[23] == 39, + "incorrect value for stub[23], expected 39, is %d", + check_msg->stub[23]); + ck_assert_msg(check_msg->stub[24] == 1, + "incorrect value for stub[24], expected 1, is %d", + check_msg->stub[24]); + ck_assert_msg(check_msg->stub[25] == 1, + "incorrect value for stub[25], expected 1, is %d", + check_msg->stub[25]); + ck_assert_msg(check_msg->stub[26] == 1, + "incorrect value for stub[26], expected 1, is %d", + check_msg->stub[26]); + ck_assert_msg(check_msg->stub[27] == 39, + "incorrect value for stub[27], expected 39, is %d", + check_msg->stub[27]); + ck_assert_msg(check_msg->stub[28] == 1, + "incorrect value for stub[28], expected 1, is %d", + check_msg->stub[28]); + ck_assert_msg(check_msg->stub[29] == 39, + "incorrect value for stub[29], expected 39, is %d", + check_msg->stub[29]); + ck_assert_msg(check_msg->stub[30] == 1, + "incorrect value for stub[30], expected 1, is %d", + check_msg->stub[30]); + } +} +END_TEST + +Suite *legacy_auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "legacy_auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds"); + TCase *tc_acq = tcase_create( + "Automated_Suite_legacy_auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds"); + tcase_add_test(tc_acq, + test_legacy_auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/legacy/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds.c b/c/test/legacy/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds.c new file mode 100644 index 0000000000..734c5651e0 --- /dev/null +++ b/c/test/legacy/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds.c @@ -0,0 +1,553 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrectionBounds.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u8 len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + void *context; +} last_msg; + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u16 msg_type; + u8 msg_len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + u16 frame_len; + u8 frame[SBP_MAX_FRAME_LEN]; + void *context; +} last_frame; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static int DUMMY_MEMORY_FOR_CALLBACKS = 0xdeadbeef; +static int DUMMY_MEMORY_FOR_IO = 0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return real_n; +} + +static void logging_reset() { + memset(&last_msg, 0, sizeof(last_msg)); + memset(&last_frame, 0, sizeof(last_frame)); +} + +static void msg_callback(u16 sender_id, u8 len, u8 msg[], void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.len = len; + last_msg.context = context; + memcpy(last_msg.msg, msg, len); +} + +static void frame_callback(u16 sender_id, u16 msg_type, u8 msg_len, u8 msg[], + u16 frame_len, u8 frame[], void *context) { + last_frame.n_callbacks_logged++; + last_frame.sender_id = sender_id; + last_frame.msg_type = msg_type; + last_frame.msg_len = msg_len; + memcpy(last_frame.msg, msg, msg_len); + last_frame.frame_len = frame_len; + memcpy(last_frame.frame, frame, frame_len); + last_frame.context = context; +} + +START_TEST(test_legacy_auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds) { + static sbp_msg_callbacks_node_t n; + static sbp_msg_callbacks_node_t n2; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_payload_callback_register(&sbp_state, 1534, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + sbp_frame_callback_register(&sbp_state, 1534, &frame_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n2); + + u8 encoded_frame[] = { + 85, 254, 5, 66, 0, 43, 180, 0, 0, 0, 3, 0, 1, + 1, 10, 0, 15, 1, 0, 10, 0, 39, 232, 3, 244, 1, + 100, 200, 150, 100, 2, 5, 10, 16, 0, 17, 18, 19, 20, + 21, 6, 10, 22, 0, 23, 24, 25, 26, 27, 112, 145, + }; + + dummy_reset(); + + u8 test_msg_storage[SBP_MAX_PAYLOAD_LEN]; + memset(test_msg_storage, 0, sizeof(test_msg_storage)); + u8 test_msg_len = 0; + msg_ssr_gridded_correction_bounds_t *test_msg = + (msg_ssr_gridded_correction_bounds_t *)test_msg_storage; + test_msg_len = sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[7] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[8] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[9] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[10] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[11] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[12] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[13] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[14] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[15] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[16] = 232; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[17] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[18] = 244; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[19] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[20] = 100; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[21] = 200; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[22] = 150; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[23] = 100; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[24] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[25] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[26] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[27] = 16; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[28] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[29] = 17; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[30] = 18; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[31] = 19; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[32] = 20; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[33] = 21; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[34] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[35] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[36] = 22; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[37] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[38] = 23; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[39] = 24; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[40] = 25; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[41] = 26; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[42] = 27; + sbp_payload_send(&sbp_state, 1534, 66, test_msg_len, test_msg_storage, + &dummy_write); + + ck_assert_msg( + test_msg_len == sizeof(encoded_frame) - 8, + "Test message has not been generated correctly, or the encoded frame " + "from the spec is badly defined. Check your test spec"); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff"); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_msg.len == sizeof(encoded_frame) - 8, + "msg_callback: len decoded incorrectly"); + ck_assert_msg( + memcmp(last_msg.msg, encoded_frame + 6, sizeof(encoded_frame) - 8) == 0, + "msg_callback: test data decoded incorrectly"); + ck_assert_msg(last_msg.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + ck_assert_msg(last_frame.n_callbacks_logged == 1, + "frame_callback: one callback should have been logged"); + ck_assert_msg(last_frame.sender_id == 66, + "frame_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_frame.msg_type == 1534, + "frame_callback: msg_type decoded incorrectly"); + ck_assert_msg(last_frame.msg_len == sizeof(encoded_frame) - 8, + "frame_callback: msg_len decoded incorrectly"); + ck_assert_msg(memcmp(last_frame.msg, encoded_frame + 6, + sizeof(encoded_frame) - 8) == 0, + "frame_callback: test data decoded incorrectly"); + ck_assert_msg(last_frame.frame_len == sizeof(encoded_frame), + "frame_callback: frame_len decoded incorrectly"); + ck_assert_msg( + memcmp(last_frame.frame, encoded_frame, sizeof(encoded_frame)) == 0, + "frame_callback: frame decoded incorrectly"); + ck_assert_msg(last_frame.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + // Cast to expected message type - the +6 byte offset is where the payload + // starts + msg_ssr_gridded_correction_bounds_t *check_msg = + (msg_ssr_gridded_correction_bounds_t *)((void *)last_msg.msg); + // Run tests against fields + ck_assert_msg(check_msg != 0, "stub to prevent warnings if msg isn't used"); + ck_assert_msg(check_msg->stub[0] == 180, + "incorrect value for stub[0], expected 180, is %d", + check_msg->stub[0]); + ck_assert_msg(check_msg->stub[1] == 0, + "incorrect value for stub[1], expected 0, is %d", + check_msg->stub[1]); + ck_assert_msg(check_msg->stub[2] == 0, + "incorrect value for stub[2], expected 0, is %d", + check_msg->stub[2]); + ck_assert_msg(check_msg->stub[3] == 0, + "incorrect value for stub[3], expected 0, is %d", + check_msg->stub[3]); + ck_assert_msg(check_msg->stub[4] == 3, + "incorrect value for stub[4], expected 3, is %d", + check_msg->stub[4]); + ck_assert_msg(check_msg->stub[5] == 0, + "incorrect value for stub[5], expected 0, is %d", + check_msg->stub[5]); + ck_assert_msg(check_msg->stub[6] == 1, + "incorrect value for stub[6], expected 1, is %d", + check_msg->stub[6]); + ck_assert_msg(check_msg->stub[7] == 1, + "incorrect value for stub[7], expected 1, is %d", + check_msg->stub[7]); + ck_assert_msg(check_msg->stub[8] == 10, + "incorrect value for stub[8], expected 10, is %d", + check_msg->stub[8]); + ck_assert_msg(check_msg->stub[9] == 0, + "incorrect value for stub[9], expected 0, is %d", + check_msg->stub[9]); + ck_assert_msg(check_msg->stub[10] == 15, + "incorrect value for stub[10], expected 15, is %d", + check_msg->stub[10]); + ck_assert_msg(check_msg->stub[11] == 1, + "incorrect value for stub[11], expected 1, is %d", + check_msg->stub[11]); + ck_assert_msg(check_msg->stub[12] == 0, + "incorrect value for stub[12], expected 0, is %d", + check_msg->stub[12]); + ck_assert_msg(check_msg->stub[13] == 10, + "incorrect value for stub[13], expected 10, is %d", + check_msg->stub[13]); + ck_assert_msg(check_msg->stub[14] == 0, + "incorrect value for stub[14], expected 0, is %d", + check_msg->stub[14]); + ck_assert_msg(check_msg->stub[15] == 39, + "incorrect value for stub[15], expected 39, is %d", + check_msg->stub[15]); + ck_assert_msg(check_msg->stub[16] == 232, + "incorrect value for stub[16], expected 232, is %d", + check_msg->stub[16]); + ck_assert_msg(check_msg->stub[17] == 3, + "incorrect value for stub[17], expected 3, is %d", + check_msg->stub[17]); + ck_assert_msg(check_msg->stub[18] == 244, + "incorrect value for stub[18], expected 244, is %d", + check_msg->stub[18]); + ck_assert_msg(check_msg->stub[19] == 1, + "incorrect value for stub[19], expected 1, is %d", + check_msg->stub[19]); + ck_assert_msg(check_msg->stub[20] == 100, + "incorrect value for stub[20], expected 100, is %d", + check_msg->stub[20]); + ck_assert_msg(check_msg->stub[21] == 200, + "incorrect value for stub[21], expected 200, is %d", + check_msg->stub[21]); + ck_assert_msg(check_msg->stub[22] == 150, + "incorrect value for stub[22], expected 150, is %d", + check_msg->stub[22]); + ck_assert_msg(check_msg->stub[23] == 100, + "incorrect value for stub[23], expected 100, is %d", + check_msg->stub[23]); + ck_assert_msg(check_msg->stub[24] == 2, + "incorrect value for stub[24], expected 2, is %d", + check_msg->stub[24]); + ck_assert_msg(check_msg->stub[25] == 5, + "incorrect value for stub[25], expected 5, is %d", + check_msg->stub[25]); + ck_assert_msg(check_msg->stub[26] == 10, + "incorrect value for stub[26], expected 10, is %d", + check_msg->stub[26]); + ck_assert_msg(check_msg->stub[27] == 16, + "incorrect value for stub[27], expected 16, is %d", + check_msg->stub[27]); + ck_assert_msg(check_msg->stub[28] == 0, + "incorrect value for stub[28], expected 0, is %d", + check_msg->stub[28]); + ck_assert_msg(check_msg->stub[29] == 17, + "incorrect value for stub[29], expected 17, is %d", + check_msg->stub[29]); + ck_assert_msg(check_msg->stub[30] == 18, + "incorrect value for stub[30], expected 18, is %d", + check_msg->stub[30]); + ck_assert_msg(check_msg->stub[31] == 19, + "incorrect value for stub[31], expected 19, is %d", + check_msg->stub[31]); + ck_assert_msg(check_msg->stub[32] == 20, + "incorrect value for stub[32], expected 20, is %d", + check_msg->stub[32]); + ck_assert_msg(check_msg->stub[33] == 21, + "incorrect value for stub[33], expected 21, is %d", + check_msg->stub[33]); + ck_assert_msg(check_msg->stub[34] == 6, + "incorrect value for stub[34], expected 6, is %d", + check_msg->stub[34]); + ck_assert_msg(check_msg->stub[35] == 10, + "incorrect value for stub[35], expected 10, is %d", + check_msg->stub[35]); + ck_assert_msg(check_msg->stub[36] == 22, + "incorrect value for stub[36], expected 22, is %d", + check_msg->stub[36]); + ck_assert_msg(check_msg->stub[37] == 0, + "incorrect value for stub[37], expected 0, is %d", + check_msg->stub[37]); + ck_assert_msg(check_msg->stub[38] == 23, + "incorrect value for stub[38], expected 23, is %d", + check_msg->stub[38]); + ck_assert_msg(check_msg->stub[39] == 24, + "incorrect value for stub[39], expected 24, is %d", + check_msg->stub[39]); + ck_assert_msg(check_msg->stub[40] == 25, + "incorrect value for stub[40], expected 25, is %d", + check_msg->stub[40]); + ck_assert_msg(check_msg->stub[41] == 26, + "incorrect value for stub[41], expected 26, is %d", + check_msg->stub[41]); + ck_assert_msg(check_msg->stub[42] == 27, + "incorrect value for stub[42], expected 27, is %d", + check_msg->stub[42]); + } +} +END_TEST + +Suite *legacy_auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "legacy_auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds"); + TCase *tc_acq = tcase_create( + "Automated_Suite_legacy_auto_check_sbp_ssr_" + "MsgSsrGriddedCorrectionBounds"); + tcase_add_test(tc_acq, + test_legacy_auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/legacy/auto_check_sbp_ssr_MsgSsrOrbitClockBounds.c b/c/test/legacy/auto_check_sbp_ssr_MsgSsrOrbitClockBounds.c new file mode 100644 index 0000000000..ff004cec6a --- /dev/null +++ b/c/test/legacy/auto_check_sbp_ssr_MsgSsrOrbitClockBounds.c @@ -0,0 +1,454 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBounds.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u8 len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + void *context; +} last_msg; + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u16 msg_type; + u8 msg_len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + u16 frame_len; + u8 frame[SBP_MAX_FRAME_LEN]; + void *context; +} last_frame; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static int DUMMY_MEMORY_FOR_CALLBACKS = 0xdeadbeef; +static int DUMMY_MEMORY_FOR_IO = 0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return real_n; +} + +static void logging_reset() { + memset(&last_msg, 0, sizeof(last_msg)); + memset(&last_frame, 0, sizeof(last_frame)); +} + +static void msg_callback(u16 sender_id, u8 len, u8 msg[], void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.len = len; + last_msg.context = context; + memcpy(last_msg.msg, msg, len); +} + +static void frame_callback(u16 sender_id, u16 msg_type, u8 msg_len, u8 msg[], + u16 frame_len, u8 frame[], void *context) { + last_frame.n_callbacks_logged++; + last_frame.sender_id = sender_id; + last_frame.msg_type = msg_type; + last_frame.msg_len = msg_len; + memcpy(last_frame.msg, msg, msg_len); + last_frame.frame_len = frame_len; + memcpy(last_frame.frame, frame, frame_len); + last_frame.context = context; +} + +START_TEST(test_legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBounds) { + static sbp_msg_callbacks_node_t n; + static sbp_msg_callbacks_node_t n2; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_payload_callback_register(&sbp_state, 1502, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + sbp_frame_callback_register(&sbp_state, 1502, &frame_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n2); + + u8 encoded_frame[] = { + 85, 222, 5, 66, 0, 31, 180, 0, 0, 0, 3, 0, 1, + 2, 3, 48, 15, 1, 2, 24, 39, 38, 37, 1, 2, 3, + 39, 1, 3, 39, 38, 37, 1, 2, 3, 39, 1, 21, 85, + }; + + dummy_reset(); + + u8 test_msg_storage[SBP_MAX_PAYLOAD_LEN]; + memset(test_msg_storage, 0, sizeof(test_msg_storage)); + u8 test_msg_len = 0; + msg_ssr_orbit_clock_bounds_t *test_msg = + (msg_ssr_orbit_clock_bounds_t *)test_msg_storage; + test_msg_len = sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[7] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[8] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[9] = 48; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[10] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[11] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[12] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[13] = 24; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[14] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[15] = 38; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[16] = 37; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[17] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[18] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[19] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[20] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[21] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[22] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[23] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[24] = 38; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[25] = 37; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[26] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[27] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[28] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[29] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[30] = 1; + sbp_payload_send(&sbp_state, 1502, 66, test_msg_len, test_msg_storage, + &dummy_write); + + ck_assert_msg( + test_msg_len == sizeof(encoded_frame) - 8, + "Test message has not been generated correctly, or the encoded frame " + "from the spec is badly defined. Check your test spec"); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff"); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_msg.len == sizeof(encoded_frame) - 8, + "msg_callback: len decoded incorrectly"); + ck_assert_msg( + memcmp(last_msg.msg, encoded_frame + 6, sizeof(encoded_frame) - 8) == 0, + "msg_callback: test data decoded incorrectly"); + ck_assert_msg(last_msg.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + ck_assert_msg(last_frame.n_callbacks_logged == 1, + "frame_callback: one callback should have been logged"); + ck_assert_msg(last_frame.sender_id == 66, + "frame_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_frame.msg_type == 1502, + "frame_callback: msg_type decoded incorrectly"); + ck_assert_msg(last_frame.msg_len == sizeof(encoded_frame) - 8, + "frame_callback: msg_len decoded incorrectly"); + ck_assert_msg(memcmp(last_frame.msg, encoded_frame + 6, + sizeof(encoded_frame) - 8) == 0, + "frame_callback: test data decoded incorrectly"); + ck_assert_msg(last_frame.frame_len == sizeof(encoded_frame), + "frame_callback: frame_len decoded incorrectly"); + ck_assert_msg( + memcmp(last_frame.frame, encoded_frame, sizeof(encoded_frame)) == 0, + "frame_callback: frame decoded incorrectly"); + ck_assert_msg(last_frame.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + // Cast to expected message type - the +6 byte offset is where the payload + // starts + msg_ssr_orbit_clock_bounds_t *check_msg = + (msg_ssr_orbit_clock_bounds_t *)((void *)last_msg.msg); + // Run tests against fields + ck_assert_msg(check_msg != 0, "stub to prevent warnings if msg isn't used"); + ck_assert_msg(check_msg->stub[0] == 180, + "incorrect value for stub[0], expected 180, is %d", + check_msg->stub[0]); + ck_assert_msg(check_msg->stub[1] == 0, + "incorrect value for stub[1], expected 0, is %d", + check_msg->stub[1]); + ck_assert_msg(check_msg->stub[2] == 0, + "incorrect value for stub[2], expected 0, is %d", + check_msg->stub[2]); + ck_assert_msg(check_msg->stub[3] == 0, + "incorrect value for stub[3], expected 0, is %d", + check_msg->stub[3]); + ck_assert_msg(check_msg->stub[4] == 3, + "incorrect value for stub[4], expected 3, is %d", + check_msg->stub[4]); + ck_assert_msg(check_msg->stub[5] == 0, + "incorrect value for stub[5], expected 0, is %d", + check_msg->stub[5]); + ck_assert_msg(check_msg->stub[6] == 1, + "incorrect value for stub[6], expected 1, is %d", + check_msg->stub[6]); + ck_assert_msg(check_msg->stub[7] == 2, + "incorrect value for stub[7], expected 2, is %d", + check_msg->stub[7]); + ck_assert_msg(check_msg->stub[8] == 3, + "incorrect value for stub[8], expected 3, is %d", + check_msg->stub[8]); + ck_assert_msg(check_msg->stub[9] == 48, + "incorrect value for stub[9], expected 48, is %d", + check_msg->stub[9]); + ck_assert_msg(check_msg->stub[10] == 15, + "incorrect value for stub[10], expected 15, is %d", + check_msg->stub[10]); + ck_assert_msg(check_msg->stub[11] == 1, + "incorrect value for stub[11], expected 1, is %d", + check_msg->stub[11]); + ck_assert_msg(check_msg->stub[12] == 2, + "incorrect value for stub[12], expected 2, is %d", + check_msg->stub[12]); + ck_assert_msg(check_msg->stub[13] == 24, + "incorrect value for stub[13], expected 24, is %d", + check_msg->stub[13]); + ck_assert_msg(check_msg->stub[14] == 39, + "incorrect value for stub[14], expected 39, is %d", + check_msg->stub[14]); + ck_assert_msg(check_msg->stub[15] == 38, + "incorrect value for stub[15], expected 38, is %d", + check_msg->stub[15]); + ck_assert_msg(check_msg->stub[16] == 37, + "incorrect value for stub[16], expected 37, is %d", + check_msg->stub[16]); + ck_assert_msg(check_msg->stub[17] == 1, + "incorrect value for stub[17], expected 1, is %d", + check_msg->stub[17]); + ck_assert_msg(check_msg->stub[18] == 2, + "incorrect value for stub[18], expected 2, is %d", + check_msg->stub[18]); + ck_assert_msg(check_msg->stub[19] == 3, + "incorrect value for stub[19], expected 3, is %d", + check_msg->stub[19]); + ck_assert_msg(check_msg->stub[20] == 39, + "incorrect value for stub[20], expected 39, is %d", + check_msg->stub[20]); + ck_assert_msg(check_msg->stub[21] == 1, + "incorrect value for stub[21], expected 1, is %d", + check_msg->stub[21]); + ck_assert_msg(check_msg->stub[22] == 3, + "incorrect value for stub[22], expected 3, is %d", + check_msg->stub[22]); + ck_assert_msg(check_msg->stub[23] == 39, + "incorrect value for stub[23], expected 39, is %d", + check_msg->stub[23]); + ck_assert_msg(check_msg->stub[24] == 38, + "incorrect value for stub[24], expected 38, is %d", + check_msg->stub[24]); + ck_assert_msg(check_msg->stub[25] == 37, + "incorrect value for stub[25], expected 37, is %d", + check_msg->stub[25]); + ck_assert_msg(check_msg->stub[26] == 1, + "incorrect value for stub[26], expected 1, is %d", + check_msg->stub[26]); + ck_assert_msg(check_msg->stub[27] == 2, + "incorrect value for stub[27], expected 2, is %d", + check_msg->stub[27]); + ck_assert_msg(check_msg->stub[28] == 3, + "incorrect value for stub[28], expected 3, is %d", + check_msg->stub[28]); + ck_assert_msg(check_msg->stub[29] == 39, + "incorrect value for stub[29], expected 39, is %d", + check_msg->stub[29]); + ck_assert_msg(check_msg->stub[30] == 1, + "incorrect value for stub[30], expected 1, is %d", + check_msg->stub[30]); + } +} +END_TEST + +Suite *legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBounds_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBounds"); + TCase *tc_acq = tcase_create( + "Automated_Suite_legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBounds"); + tcase_add_test(tc_acq, test_legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBounds); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/legacy/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation.c b/c/test/legacy/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation.c new file mode 100644 index 0000000000..e19dff19de --- /dev/null +++ b/c/test/legacy/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation.c @@ -0,0 +1,432 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBoundsDegradation.yaml +// by generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u8 len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + void *context; +} last_msg; + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u16 msg_type; + u8 msg_len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + u16 frame_len; + u8 frame[SBP_MAX_FRAME_LEN]; + void *context; +} last_frame; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static int DUMMY_MEMORY_FOR_CALLBACKS = 0xdeadbeef; +static int DUMMY_MEMORY_FOR_IO = 0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return real_n; +} + +static void logging_reset() { + memset(&last_msg, 0, sizeof(last_msg)); + memset(&last_frame, 0, sizeof(last_frame)); +} + +static void msg_callback(u16 sender_id, u8 len, u8 msg[], void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.len = len; + last_msg.context = context; + memcpy(last_msg.msg, msg, len); +} + +static void frame_callback(u16 sender_id, u16 msg_type, u8 msg_len, u8 msg[], + u16 frame_len, u8 frame[], void *context) { + last_frame.n_callbacks_logged++; + last_frame.sender_id = sender_id; + last_frame.msg_type = msg_type; + last_frame.msg_len = msg_len; + memcpy(last_frame.msg, msg, msg_len); + last_frame.frame_len = frame_len; + memcpy(last_frame.frame, frame, frame_len); + last_frame.context = context; +} + +START_TEST(test_legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation) { + static sbp_msg_callbacks_node_t n; + static sbp_msg_callbacks_node_t n2; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_payload_callback_register(&sbp_state, 1503, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + sbp_frame_callback_register(&sbp_state, 1503, &frame_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n2); + + u8 encoded_frame[] = { + 85, 223, 5, 66, 0, 28, 180, 0, 0, 0, 3, 0, + 1, 2, 3, 48, 15, 1, 10, 0, 0, 0, 0, 0, + 0, 0, 200, 199, 198, 197, 196, 195, 194, 193, 200, 117, + }; + + dummy_reset(); + + u8 test_msg_storage[SBP_MAX_PAYLOAD_LEN]; + memset(test_msg_storage, 0, sizeof(test_msg_storage)); + u8 test_msg_len = 0; + msg_ssr_orbit_clock_bounds_degradation_t *test_msg = + (msg_ssr_orbit_clock_bounds_degradation_t *)test_msg_storage; + test_msg_len = sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[7] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[8] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[9] = 48; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[10] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[11] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[12] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[13] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[14] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[15] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[16] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[17] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[18] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[19] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[20] = 200; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[21] = 199; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[22] = 198; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[23] = 197; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[24] = 196; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[25] = 195; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[26] = 194; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[27] = 193; + sbp_payload_send(&sbp_state, 1503, 66, test_msg_len, test_msg_storage, + &dummy_write); + + ck_assert_msg( + test_msg_len == sizeof(encoded_frame) - 8, + "Test message has not been generated correctly, or the encoded frame " + "from the spec is badly defined. Check your test spec"); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff"); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_msg.len == sizeof(encoded_frame) - 8, + "msg_callback: len decoded incorrectly"); + ck_assert_msg( + memcmp(last_msg.msg, encoded_frame + 6, sizeof(encoded_frame) - 8) == 0, + "msg_callback: test data decoded incorrectly"); + ck_assert_msg(last_msg.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + ck_assert_msg(last_frame.n_callbacks_logged == 1, + "frame_callback: one callback should have been logged"); + ck_assert_msg(last_frame.sender_id == 66, + "frame_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_frame.msg_type == 1503, + "frame_callback: msg_type decoded incorrectly"); + ck_assert_msg(last_frame.msg_len == sizeof(encoded_frame) - 8, + "frame_callback: msg_len decoded incorrectly"); + ck_assert_msg(memcmp(last_frame.msg, encoded_frame + 6, + sizeof(encoded_frame) - 8) == 0, + "frame_callback: test data decoded incorrectly"); + ck_assert_msg(last_frame.frame_len == sizeof(encoded_frame), + "frame_callback: frame_len decoded incorrectly"); + ck_assert_msg( + memcmp(last_frame.frame, encoded_frame, sizeof(encoded_frame)) == 0, + "frame_callback: frame decoded incorrectly"); + ck_assert_msg(last_frame.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + // Cast to expected message type - the +6 byte offset is where the payload + // starts + msg_ssr_orbit_clock_bounds_degradation_t *check_msg = + (msg_ssr_orbit_clock_bounds_degradation_t *)((void *)last_msg.msg); + // Run tests against fields + ck_assert_msg(check_msg != 0, "stub to prevent warnings if msg isn't used"); + ck_assert_msg(check_msg->stub[0] == 180, + "incorrect value for stub[0], expected 180, is %d", + check_msg->stub[0]); + ck_assert_msg(check_msg->stub[1] == 0, + "incorrect value for stub[1], expected 0, is %d", + check_msg->stub[1]); + ck_assert_msg(check_msg->stub[2] == 0, + "incorrect value for stub[2], expected 0, is %d", + check_msg->stub[2]); + ck_assert_msg(check_msg->stub[3] == 0, + "incorrect value for stub[3], expected 0, is %d", + check_msg->stub[3]); + ck_assert_msg(check_msg->stub[4] == 3, + "incorrect value for stub[4], expected 3, is %d", + check_msg->stub[4]); + ck_assert_msg(check_msg->stub[5] == 0, + "incorrect value for stub[5], expected 0, is %d", + check_msg->stub[5]); + ck_assert_msg(check_msg->stub[6] == 1, + "incorrect value for stub[6], expected 1, is %d", + check_msg->stub[6]); + ck_assert_msg(check_msg->stub[7] == 2, + "incorrect value for stub[7], expected 2, is %d", + check_msg->stub[7]); + ck_assert_msg(check_msg->stub[8] == 3, + "incorrect value for stub[8], expected 3, is %d", + check_msg->stub[8]); + ck_assert_msg(check_msg->stub[9] == 48, + "incorrect value for stub[9], expected 48, is %d", + check_msg->stub[9]); + ck_assert_msg(check_msg->stub[10] == 15, + "incorrect value for stub[10], expected 15, is %d", + check_msg->stub[10]); + ck_assert_msg(check_msg->stub[11] == 1, + "incorrect value for stub[11], expected 1, is %d", + check_msg->stub[11]); + ck_assert_msg(check_msg->stub[12] == 10, + "incorrect value for stub[12], expected 10, is %d", + check_msg->stub[12]); + ck_assert_msg(check_msg->stub[13] == 0, + "incorrect value for stub[13], expected 0, is %d", + check_msg->stub[13]); + ck_assert_msg(check_msg->stub[14] == 0, + "incorrect value for stub[14], expected 0, is %d", + check_msg->stub[14]); + ck_assert_msg(check_msg->stub[15] == 0, + "incorrect value for stub[15], expected 0, is %d", + check_msg->stub[15]); + ck_assert_msg(check_msg->stub[16] == 0, + "incorrect value for stub[16], expected 0, is %d", + check_msg->stub[16]); + ck_assert_msg(check_msg->stub[17] == 0, + "incorrect value for stub[17], expected 0, is %d", + check_msg->stub[17]); + ck_assert_msg(check_msg->stub[18] == 0, + "incorrect value for stub[18], expected 0, is %d", + check_msg->stub[18]); + ck_assert_msg(check_msg->stub[19] == 0, + "incorrect value for stub[19], expected 0, is %d", + check_msg->stub[19]); + ck_assert_msg(check_msg->stub[20] == 200, + "incorrect value for stub[20], expected 200, is %d", + check_msg->stub[20]); + ck_assert_msg(check_msg->stub[21] == 199, + "incorrect value for stub[21], expected 199, is %d", + check_msg->stub[21]); + ck_assert_msg(check_msg->stub[22] == 198, + "incorrect value for stub[22], expected 198, is %d", + check_msg->stub[22]); + ck_assert_msg(check_msg->stub[23] == 197, + "incorrect value for stub[23], expected 197, is %d", + check_msg->stub[23]); + ck_assert_msg(check_msg->stub[24] == 196, + "incorrect value for stub[24], expected 196, is %d", + check_msg->stub[24]); + ck_assert_msg(check_msg->stub[25] == 195, + "incorrect value for stub[25], expected 195, is %d", + check_msg->stub[25]); + ck_assert_msg(check_msg->stub[26] == 194, + "incorrect value for stub[26], expected 194, is %d", + check_msg->stub[26]); + ck_assert_msg(check_msg->stub[27] == 193, + "incorrect value for stub[27], expected 193, is %d", + check_msg->stub[27]); + } +} +END_TEST + +Suite *legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation"); + TCase *tc_acq = tcase_create( + "Automated_Suite_legacy_auto_check_sbp_ssr_" + "MsgSsrOrbitClockBoundsDegradation"); + tcase_add_test( + tc_acq, test_legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/legacy/auto_check_sbp_ssr_MsgSsrStecCorrection.c b/c/test/legacy/auto_check_sbp_ssr_MsgSsrStecCorrection.c new file mode 100644 index 0000000000..09ef22c1f8 --- /dev/null +++ b/c/test/legacy/auto_check_sbp_ssr_MsgSsrStecCorrection.c @@ -0,0 +1,510 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrStecCorrection.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u8 len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + void *context; +} last_msg; + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u16 msg_type; + u8 msg_len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + u16 frame_len; + u8 frame[SBP_MAX_FRAME_LEN]; + void *context; +} last_frame; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static int DUMMY_MEMORY_FOR_CALLBACKS = 0xdeadbeef; +static int DUMMY_MEMORY_FOR_IO = 0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return real_n; +} + +static void logging_reset() { + memset(&last_msg, 0, sizeof(last_msg)); + memset(&last_frame, 0, sizeof(last_frame)); +} + +static void msg_callback(u16 sender_id, u8 len, u8 msg[], void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.len = len; + last_msg.context = context; + memcpy(last_msg.msg, msg, len); +} + +static void frame_callback(u16 sender_id, u16 msg_type, u8 msg_len, u8 msg[], + u16 frame_len, u8 frame[], void *context) { + last_frame.n_callbacks_logged++; + last_frame.sender_id = sender_id; + last_frame.msg_type = msg_type; + last_frame.msg_len = msg_len; + memcpy(last_frame.msg, msg, msg_len); + last_frame.frame_len = frame_len; + memcpy(last_frame.frame, frame, frame_len); + last_frame.context = context; +} + +START_TEST(test_legacy_auto_check_sbp_ssr_MsgSsrStecCorrection) { + static sbp_msg_callbacks_node_t n; + static sbp_msg_callbacks_node_t n2; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_payload_callback_register(&sbp_state, 1533, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + sbp_frame_callback_register(&sbp_state, 1533, &frame_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n2); + + u8 encoded_frame[] = { + 85, 253, 5, 66, 0, 38, 180, 0, 0, 0, 3, 0, 1, 1, 10, 0, + 15, 1, 0, 10, 0, 2, 1, 1, 1, 63, 0, 62, 0, 61, 0, 60, + 0, 31, 15, 5, 63, 0, 64, 0, 65, 0, 66, 0, 119, 50, + }; + + dummy_reset(); + + u8 test_msg_storage[SBP_MAX_PAYLOAD_LEN]; + memset(test_msg_storage, 0, sizeof(test_msg_storage)); + u8 test_msg_len = 0; + msg_ssr_stec_correction_t *test_msg = + (msg_ssr_stec_correction_t *)test_msg_storage; + test_msg_len = sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[7] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[8] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[9] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[10] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[11] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[12] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[13] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[14] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[15] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[16] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[17] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[18] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[19] = 63; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[20] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[21] = 62; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[22] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[23] = 61; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[24] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[25] = 60; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[26] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[27] = 31; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[28] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[29] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[30] = 63; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[31] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[32] = 64; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[33] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[34] = 65; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[35] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[36] = 66; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[37] = 0; + sbp_payload_send(&sbp_state, 1533, 66, test_msg_len, test_msg_storage, + &dummy_write); + + ck_assert_msg( + test_msg_len == sizeof(encoded_frame) - 8, + "Test message has not been generated correctly, or the encoded frame " + "from the spec is badly defined. Check your test spec"); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff"); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_msg.len == sizeof(encoded_frame) - 8, + "msg_callback: len decoded incorrectly"); + ck_assert_msg( + memcmp(last_msg.msg, encoded_frame + 6, sizeof(encoded_frame) - 8) == 0, + "msg_callback: test data decoded incorrectly"); + ck_assert_msg(last_msg.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + ck_assert_msg(last_frame.n_callbacks_logged == 1, + "frame_callback: one callback should have been logged"); + ck_assert_msg(last_frame.sender_id == 66, + "frame_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_frame.msg_type == 1533, + "frame_callback: msg_type decoded incorrectly"); + ck_assert_msg(last_frame.msg_len == sizeof(encoded_frame) - 8, + "frame_callback: msg_len decoded incorrectly"); + ck_assert_msg(memcmp(last_frame.msg, encoded_frame + 6, + sizeof(encoded_frame) - 8) == 0, + "frame_callback: test data decoded incorrectly"); + ck_assert_msg(last_frame.frame_len == sizeof(encoded_frame), + "frame_callback: frame_len decoded incorrectly"); + ck_assert_msg( + memcmp(last_frame.frame, encoded_frame, sizeof(encoded_frame)) == 0, + "frame_callback: frame decoded incorrectly"); + ck_assert_msg(last_frame.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + // Cast to expected message type - the +6 byte offset is where the payload + // starts + msg_ssr_stec_correction_t *check_msg = + (msg_ssr_stec_correction_t *)((void *)last_msg.msg); + // Run tests against fields + ck_assert_msg(check_msg != 0, "stub to prevent warnings if msg isn't used"); + ck_assert_msg(check_msg->stub[0] == 180, + "incorrect value for stub[0], expected 180, is %d", + check_msg->stub[0]); + ck_assert_msg(check_msg->stub[1] == 0, + "incorrect value for stub[1], expected 0, is %d", + check_msg->stub[1]); + ck_assert_msg(check_msg->stub[2] == 0, + "incorrect value for stub[2], expected 0, is %d", + check_msg->stub[2]); + ck_assert_msg(check_msg->stub[3] == 0, + "incorrect value for stub[3], expected 0, is %d", + check_msg->stub[3]); + ck_assert_msg(check_msg->stub[4] == 3, + "incorrect value for stub[4], expected 3, is %d", + check_msg->stub[4]); + ck_assert_msg(check_msg->stub[5] == 0, + "incorrect value for stub[5], expected 0, is %d", + check_msg->stub[5]); + ck_assert_msg(check_msg->stub[6] == 1, + "incorrect value for stub[6], expected 1, is %d", + check_msg->stub[6]); + ck_assert_msg(check_msg->stub[7] == 1, + "incorrect value for stub[7], expected 1, is %d", + check_msg->stub[7]); + ck_assert_msg(check_msg->stub[8] == 10, + "incorrect value for stub[8], expected 10, is %d", + check_msg->stub[8]); + ck_assert_msg(check_msg->stub[9] == 0, + "incorrect value for stub[9], expected 0, is %d", + check_msg->stub[9]); + ck_assert_msg(check_msg->stub[10] == 15, + "incorrect value for stub[10], expected 15, is %d", + check_msg->stub[10]); + ck_assert_msg(check_msg->stub[11] == 1, + "incorrect value for stub[11], expected 1, is %d", + check_msg->stub[11]); + ck_assert_msg(check_msg->stub[12] == 0, + "incorrect value for stub[12], expected 0, is %d", + check_msg->stub[12]); + ck_assert_msg(check_msg->stub[13] == 10, + "incorrect value for stub[13], expected 10, is %d", + check_msg->stub[13]); + ck_assert_msg(check_msg->stub[14] == 0, + "incorrect value for stub[14], expected 0, is %d", + check_msg->stub[14]); + ck_assert_msg(check_msg->stub[15] == 2, + "incorrect value for stub[15], expected 2, is %d", + check_msg->stub[15]); + ck_assert_msg(check_msg->stub[16] == 1, + "incorrect value for stub[16], expected 1, is %d", + check_msg->stub[16]); + ck_assert_msg(check_msg->stub[17] == 1, + "incorrect value for stub[17], expected 1, is %d", + check_msg->stub[17]); + ck_assert_msg(check_msg->stub[18] == 1, + "incorrect value for stub[18], expected 1, is %d", + check_msg->stub[18]); + ck_assert_msg(check_msg->stub[19] == 63, + "incorrect value for stub[19], expected 63, is %d", + check_msg->stub[19]); + ck_assert_msg(check_msg->stub[20] == 0, + "incorrect value for stub[20], expected 0, is %d", + check_msg->stub[20]); + ck_assert_msg(check_msg->stub[21] == 62, + "incorrect value for stub[21], expected 62, is %d", + check_msg->stub[21]); + ck_assert_msg(check_msg->stub[22] == 0, + "incorrect value for stub[22], expected 0, is %d", + check_msg->stub[22]); + ck_assert_msg(check_msg->stub[23] == 61, + "incorrect value for stub[23], expected 61, is %d", + check_msg->stub[23]); + ck_assert_msg(check_msg->stub[24] == 0, + "incorrect value for stub[24], expected 0, is %d", + check_msg->stub[24]); + ck_assert_msg(check_msg->stub[25] == 60, + "incorrect value for stub[25], expected 60, is %d", + check_msg->stub[25]); + ck_assert_msg(check_msg->stub[26] == 0, + "incorrect value for stub[26], expected 0, is %d", + check_msg->stub[26]); + ck_assert_msg(check_msg->stub[27] == 31, + "incorrect value for stub[27], expected 31, is %d", + check_msg->stub[27]); + ck_assert_msg(check_msg->stub[28] == 15, + "incorrect value for stub[28], expected 15, is %d", + check_msg->stub[28]); + ck_assert_msg(check_msg->stub[29] == 5, + "incorrect value for stub[29], expected 5, is %d", + check_msg->stub[29]); + ck_assert_msg(check_msg->stub[30] == 63, + "incorrect value for stub[30], expected 63, is %d", + check_msg->stub[30]); + ck_assert_msg(check_msg->stub[31] == 0, + "incorrect value for stub[31], expected 0, is %d", + check_msg->stub[31]); + ck_assert_msg(check_msg->stub[32] == 64, + "incorrect value for stub[32], expected 64, is %d", + check_msg->stub[32]); + ck_assert_msg(check_msg->stub[33] == 0, + "incorrect value for stub[33], expected 0, is %d", + check_msg->stub[33]); + ck_assert_msg(check_msg->stub[34] == 65, + "incorrect value for stub[34], expected 65, is %d", + check_msg->stub[34]); + ck_assert_msg(check_msg->stub[35] == 0, + "incorrect value for stub[35], expected 0, is %d", + check_msg->stub[35]); + ck_assert_msg(check_msg->stub[36] == 66, + "incorrect value for stub[36], expected 66, is %d", + check_msg->stub[36]); + ck_assert_msg(check_msg->stub[37] == 0, + "incorrect value for stub[37], expected 0, is %d", + check_msg->stub[37]); + } +} +END_TEST + +Suite *legacy_auto_check_sbp_ssr_MsgSsrStecCorrection_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "legacy_auto_check_sbp_ssr_MsgSsrStecCorrection"); + TCase *tc_acq = tcase_create( + "Automated_Suite_legacy_auto_check_sbp_ssr_MsgSsrStecCorrection"); + tcase_add_test(tc_acq, test_legacy_auto_check_sbp_ssr_MsgSsrStecCorrection); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/legacy/auto_check_sbp_ssr_MsgSsrTileDefinition.c b/c/test/legacy/auto_check_sbp_ssr_MsgSsrTileDefinition.c new file mode 100644 index 0000000000..5c30cd22c8 --- /dev/null +++ b/c/test/legacy/auto_check_sbp_ssr_MsgSsrTileDefinition.c @@ -0,0 +1,405 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrTileDefinition.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u8 len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + void *context; +} last_msg; + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u16 msg_type; + u8 msg_len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + u16 frame_len; + u8 frame[SBP_MAX_FRAME_LEN]; + void *context; +} last_frame; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static int DUMMY_MEMORY_FOR_CALLBACKS = 0xdeadbeef; +static int DUMMY_MEMORY_FOR_IO = 0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return real_n; +} + +static void logging_reset() { + memset(&last_msg, 0, sizeof(last_msg)); + memset(&last_frame, 0, sizeof(last_frame)); +} + +static void msg_callback(u16 sender_id, u8 len, u8 msg[], void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.len = len; + last_msg.context = context; + memcpy(last_msg.msg, msg, len); +} + +static void frame_callback(u16 sender_id, u16 msg_type, u8 msg_len, u8 msg[], + u16 frame_len, u8 frame[], void *context) { + last_frame.n_callbacks_logged++; + last_frame.sender_id = sender_id; + last_frame.msg_type = msg_type; + last_frame.msg_len = msg_len; + memcpy(last_frame.msg, msg, msg_len); + last_frame.frame_len = frame_len; + memcpy(last_frame.frame, frame, frame_len); + last_frame.context = context; +} + +START_TEST(test_legacy_auto_check_sbp_ssr_MsgSsrTileDefinition) { + static sbp_msg_callbacks_node_t n; + static sbp_msg_callbacks_node_t n2; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_payload_callback_register(&sbp_state, 1527, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + sbp_frame_callback_register(&sbp_state, 1527, &frame_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n2); + + u8 encoded_frame[] = { + 85, 247, 5, 66, 0, 25, 31, 0, 1, 0, 2, 0, 4, 0, 8, 0, 16, + 0, 32, 0, 64, 0, 128, 210, 2, 150, 73, 0, 0, 0, 0, 214, 71, + }; + + dummy_reset(); + + u8 test_msg_storage[SBP_MAX_PAYLOAD_LEN]; + memset(test_msg_storage, 0, sizeof(test_msg_storage)); + u8 test_msg_len = 0; + msg_ssr_tile_definition_t *test_msg = + (msg_ssr_tile_definition_t *)test_msg_storage; + test_msg_len = sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[0] = 31; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[2] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[4] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[6] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[7] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[8] = 8; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[9] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[10] = 16; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[11] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[12] = 32; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[13] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[14] = 64; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[15] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[16] = 128; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[17] = 210; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[18] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[19] = 150; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[20] = 73; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[21] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[22] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[23] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len += sizeof(test_msg->stub[0]); + } + test_msg->stub[24] = 0; + sbp_payload_send(&sbp_state, 1527, 66, test_msg_len, test_msg_storage, + &dummy_write); + + ck_assert_msg( + test_msg_len == sizeof(encoded_frame) - 8, + "Test message has not been generated correctly, or the encoded frame " + "from the spec is badly defined. Check your test spec"); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff"); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_msg.len == sizeof(encoded_frame) - 8, + "msg_callback: len decoded incorrectly"); + ck_assert_msg( + memcmp(last_msg.msg, encoded_frame + 6, sizeof(encoded_frame) - 8) == 0, + "msg_callback: test data decoded incorrectly"); + ck_assert_msg(last_msg.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + ck_assert_msg(last_frame.n_callbacks_logged == 1, + "frame_callback: one callback should have been logged"); + ck_assert_msg(last_frame.sender_id == 66, + "frame_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_frame.msg_type == 1527, + "frame_callback: msg_type decoded incorrectly"); + ck_assert_msg(last_frame.msg_len == sizeof(encoded_frame) - 8, + "frame_callback: msg_len decoded incorrectly"); + ck_assert_msg(memcmp(last_frame.msg, encoded_frame + 6, + sizeof(encoded_frame) - 8) == 0, + "frame_callback: test data decoded incorrectly"); + ck_assert_msg(last_frame.frame_len == sizeof(encoded_frame), + "frame_callback: frame_len decoded incorrectly"); + ck_assert_msg( + memcmp(last_frame.frame, encoded_frame, sizeof(encoded_frame)) == 0, + "frame_callback: frame decoded incorrectly"); + ck_assert_msg(last_frame.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + // Cast to expected message type - the +6 byte offset is where the payload + // starts + msg_ssr_tile_definition_t *check_msg = + (msg_ssr_tile_definition_t *)((void *)last_msg.msg); + // Run tests against fields + ck_assert_msg(check_msg != 0, "stub to prevent warnings if msg isn't used"); + ck_assert_msg(check_msg->stub[0] == 31, + "incorrect value for stub[0], expected 31, is %d", + check_msg->stub[0]); + ck_assert_msg(check_msg->stub[1] == 0, + "incorrect value for stub[1], expected 0, is %d", + check_msg->stub[1]); + ck_assert_msg(check_msg->stub[2] == 1, + "incorrect value for stub[2], expected 1, is %d", + check_msg->stub[2]); + ck_assert_msg(check_msg->stub[3] == 0, + "incorrect value for stub[3], expected 0, is %d", + check_msg->stub[3]); + ck_assert_msg(check_msg->stub[4] == 2, + "incorrect value for stub[4], expected 2, is %d", + check_msg->stub[4]); + ck_assert_msg(check_msg->stub[5] == 0, + "incorrect value for stub[5], expected 0, is %d", + check_msg->stub[5]); + ck_assert_msg(check_msg->stub[6] == 4, + "incorrect value for stub[6], expected 4, is %d", + check_msg->stub[6]); + ck_assert_msg(check_msg->stub[7] == 0, + "incorrect value for stub[7], expected 0, is %d", + check_msg->stub[7]); + ck_assert_msg(check_msg->stub[8] == 8, + "incorrect value for stub[8], expected 8, is %d", + check_msg->stub[8]); + ck_assert_msg(check_msg->stub[9] == 0, + "incorrect value for stub[9], expected 0, is %d", + check_msg->stub[9]); + ck_assert_msg(check_msg->stub[10] == 16, + "incorrect value for stub[10], expected 16, is %d", + check_msg->stub[10]); + ck_assert_msg(check_msg->stub[11] == 0, + "incorrect value for stub[11], expected 0, is %d", + check_msg->stub[11]); + ck_assert_msg(check_msg->stub[12] == 32, + "incorrect value for stub[12], expected 32, is %d", + check_msg->stub[12]); + ck_assert_msg(check_msg->stub[13] == 0, + "incorrect value for stub[13], expected 0, is %d", + check_msg->stub[13]); + ck_assert_msg(check_msg->stub[14] == 64, + "incorrect value for stub[14], expected 64, is %d", + check_msg->stub[14]); + ck_assert_msg(check_msg->stub[15] == 0, + "incorrect value for stub[15], expected 0, is %d", + check_msg->stub[15]); + ck_assert_msg(check_msg->stub[16] == 128, + "incorrect value for stub[16], expected 128, is %d", + check_msg->stub[16]); + ck_assert_msg(check_msg->stub[17] == 210, + "incorrect value for stub[17], expected 210, is %d", + check_msg->stub[17]); + ck_assert_msg(check_msg->stub[18] == 2, + "incorrect value for stub[18], expected 2, is %d", + check_msg->stub[18]); + ck_assert_msg(check_msg->stub[19] == 150, + "incorrect value for stub[19], expected 150, is %d", + check_msg->stub[19]); + ck_assert_msg(check_msg->stub[20] == 73, + "incorrect value for stub[20], expected 73, is %d", + check_msg->stub[20]); + ck_assert_msg(check_msg->stub[21] == 0, + "incorrect value for stub[21], expected 0, is %d", + check_msg->stub[21]); + ck_assert_msg(check_msg->stub[22] == 0, + "incorrect value for stub[22], expected 0, is %d", + check_msg->stub[22]); + ck_assert_msg(check_msg->stub[23] == 0, + "incorrect value for stub[23], expected 0, is %d", + check_msg->stub[23]); + ck_assert_msg(check_msg->stub[24] == 0, + "incorrect value for stub[24], expected 0, is %d", + check_msg->stub[24]); + } +} +END_TEST + +Suite *legacy_auto_check_sbp_ssr_MsgSsrTileDefinition_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "legacy_auto_check_sbp_ssr_MsgSsrTileDefinition"); + TCase *tc_acq = tcase_create( + "Automated_Suite_legacy_auto_check_sbp_ssr_MsgSsrTileDefinition"); + tcase_add_test(tc_acq, test_legacy_auto_check_sbp_ssr_MsgSsrTileDefinition); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc b/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc new file mode 100644 index 0000000000..f5f6b05b9e --- /dev/null +++ b/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc @@ -0,0 +1,325 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +class Test_legacy_auto_check_sbp_integrity_MsgSsrFlagHighLevel0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::PayloadHandler { + public: + Test_legacy_auto_check_sbp_integrity_MsgSsrFlagHighLevel0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::PayloadHandler(this), + last_msg_storage_(), + last_msg_( + reinterpret_cast(last_msg_storage_)), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, uint8_t message_length, + const msg_ssr_flag_high_level_t &msg) override { + memcpy(last_msg_storage_, &msg, message_length); + last_msg_len_ = message_length; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + uint8_t last_msg_storage_[SBP_MAX_PAYLOAD_LEN]; + msg_ssr_flag_high_level_t *last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_legacy_auto_check_sbp_integrity_MsgSsrFlagHighLevel0, Test) { + uint8_t encoded_frame[] = { + 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, + 0, 30, 0, 40, 1, 2, 3, 0, 0, 0, 0, 0, 0, 4, 5, 6, 7, 102, 67, + }; + + uint8_t test_msg_storage[SBP_MAX_PAYLOAD_LEN]{}; + uint8_t test_msg_len = 0; + msg_ssr_flag_high_level_t *test_msg = + (msg_ssr_flag_high_level_t *)test_msg_storage; + test_msg_len = (uint8_t)sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[6] = 104; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[7] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[8] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[9] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[10] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[11] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[12] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[13] = 20; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[14] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[15] = 30; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[16] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[17] = 40; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[18] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[19] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[20] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[21] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[22] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[23] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[24] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[25] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[26] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[27] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[28] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[29] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[30] = 7; + + EXPECT_EQ(send_message(3001, 66, test_msg_len, test_msg_storage), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_len_, test_msg_len); + EXPECT_EQ(last_msg_->stub[0], 180) + << "incorrect value for stub[0], expected 180, is " << last_msg_->stub[0]; + EXPECT_EQ(last_msg_->stub[1], 0) + << "incorrect value for stub[1], expected 0, is " << last_msg_->stub[1]; + EXPECT_EQ(last_msg_->stub[2], 0) + << "incorrect value for stub[2], expected 0, is " << last_msg_->stub[2]; + EXPECT_EQ(last_msg_->stub[3], 0) + << "incorrect value for stub[3], expected 0, is " << last_msg_->stub[3]; + EXPECT_EQ(last_msg_->stub[4], 3) + << "incorrect value for stub[4], expected 3, is " << last_msg_->stub[4]; + EXPECT_EQ(last_msg_->stub[5], 0) + << "incorrect value for stub[5], expected 0, is " << last_msg_->stub[5]; + EXPECT_EQ(last_msg_->stub[6], 104) + << "incorrect value for stub[6], expected 104, is " << last_msg_->stub[6]; + EXPECT_EQ(last_msg_->stub[7], 1) + << "incorrect value for stub[7], expected 1, is " << last_msg_->stub[7]; + EXPECT_EQ(last_msg_->stub[8], 0) + << "incorrect value for stub[8], expected 0, is " << last_msg_->stub[8]; + EXPECT_EQ(last_msg_->stub[9], 0) + << "incorrect value for stub[9], expected 0, is " << last_msg_->stub[9]; + EXPECT_EQ(last_msg_->stub[10], 6) + << "incorrect value for stub[10], expected 6, is " << last_msg_->stub[10]; + EXPECT_EQ(last_msg_->stub[11], 0) + << "incorrect value for stub[11], expected 0, is " << last_msg_->stub[11]; + EXPECT_EQ(last_msg_->stub[12], 10) + << "incorrect value for stub[12], expected 10, is " + << last_msg_->stub[12]; + EXPECT_EQ(last_msg_->stub[13], 20) + << "incorrect value for stub[13], expected 20, is " + << last_msg_->stub[13]; + EXPECT_EQ(last_msg_->stub[14], 0) + << "incorrect value for stub[14], expected 0, is " << last_msg_->stub[14]; + EXPECT_EQ(last_msg_->stub[15], 30) + << "incorrect value for stub[15], expected 30, is " + << last_msg_->stub[15]; + EXPECT_EQ(last_msg_->stub[16], 0) + << "incorrect value for stub[16], expected 0, is " << last_msg_->stub[16]; + EXPECT_EQ(last_msg_->stub[17], 40) + << "incorrect value for stub[17], expected 40, is " + << last_msg_->stub[17]; + EXPECT_EQ(last_msg_->stub[18], 1) + << "incorrect value for stub[18], expected 1, is " << last_msg_->stub[18]; + EXPECT_EQ(last_msg_->stub[19], 2) + << "incorrect value for stub[19], expected 2, is " << last_msg_->stub[19]; + EXPECT_EQ(last_msg_->stub[20], 3) + << "incorrect value for stub[20], expected 3, is " << last_msg_->stub[20]; + EXPECT_EQ(last_msg_->stub[21], 0) + << "incorrect value for stub[21], expected 0, is " << last_msg_->stub[21]; + EXPECT_EQ(last_msg_->stub[22], 0) + << "incorrect value for stub[22], expected 0, is " << last_msg_->stub[22]; + EXPECT_EQ(last_msg_->stub[23], 0) + << "incorrect value for stub[23], expected 0, is " << last_msg_->stub[23]; + EXPECT_EQ(last_msg_->stub[24], 0) + << "incorrect value for stub[24], expected 0, is " << last_msg_->stub[24]; + EXPECT_EQ(last_msg_->stub[25], 0) + << "incorrect value for stub[25], expected 0, is " << last_msg_->stub[25]; + EXPECT_EQ(last_msg_->stub[26], 0) + << "incorrect value for stub[26], expected 0, is " << last_msg_->stub[26]; + EXPECT_EQ(last_msg_->stub[27], 4) + << "incorrect value for stub[27], expected 4, is " << last_msg_->stub[27]; + EXPECT_EQ(last_msg_->stub[28], 5) + << "incorrect value for stub[28], expected 5, is " << last_msg_->stub[28]; + EXPECT_EQ(last_msg_->stub[29], 6) + << "incorrect value for stub[29], expected 6, is " << last_msg_->stub[29]; + EXPECT_EQ(last_msg_->stub[30], 7) + << "incorrect value for stub[30], expected 7, is " << last_msg_->stub[30]; +} diff --git a/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos.cc b/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos.cc new file mode 100644 index 0000000000..7d41edf293 --- /dev/null +++ b/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos.cc @@ -0,0 +1,258 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPointSatLos.yaml +// by generate.py. Do not modify by hand! + +#include +#include +#include +#include +class Test_legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::PayloadHandler { + public: + Test_legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::PayloadHandler(this), + last_msg_storage_(), + last_msg_(reinterpret_cast( + last_msg_storage_)), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg( + uint16_t sender_id, uint8_t message_length, + const msg_ssr_flag_iono_grid_point_sat_los_t &msg) override { + memcpy(last_msg_storage_, &msg, message_length); + last_msg_len_ = message_length; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + uint8_t last_msg_storage_[SBP_MAX_PAYLOAD_LEN]; + msg_ssr_flag_iono_grid_point_sat_los_t *last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos0, + Test) { + uint8_t encoded_frame[] = { + 85, 209, 11, 66, 0, 21, 180, 0, 0, 0, 3, 0, 1, 2, 3, + 4, 0, 5, 0, 6, 30, 0, 2, 10, 11, 15, 14, 98, 148, + }; + + uint8_t test_msg_storage[SBP_MAX_PAYLOAD_LEN]{}; + uint8_t test_msg_len = 0; + msg_ssr_flag_iono_grid_point_sat_los_t *test_msg = + (msg_ssr_flag_iono_grid_point_sat_los_t *)test_msg_storage; + test_msg_len = (uint8_t)sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[7] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[8] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[9] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[10] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[11] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[12] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[13] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[14] = 30; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[15] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[16] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[17] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[18] = 11; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[19] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[20] = 14; + + EXPECT_EQ(send_message(3025, 66, test_msg_len, test_msg_storage), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_len_, test_msg_len); + EXPECT_EQ(last_msg_->stub[0], 180) + << "incorrect value for stub[0], expected 180, is " << last_msg_->stub[0]; + EXPECT_EQ(last_msg_->stub[1], 0) + << "incorrect value for stub[1], expected 0, is " << last_msg_->stub[1]; + EXPECT_EQ(last_msg_->stub[2], 0) + << "incorrect value for stub[2], expected 0, is " << last_msg_->stub[2]; + EXPECT_EQ(last_msg_->stub[3], 0) + << "incorrect value for stub[3], expected 0, is " << last_msg_->stub[3]; + EXPECT_EQ(last_msg_->stub[4], 3) + << "incorrect value for stub[4], expected 3, is " << last_msg_->stub[4]; + EXPECT_EQ(last_msg_->stub[5], 0) + << "incorrect value for stub[5], expected 0, is " << last_msg_->stub[5]; + EXPECT_EQ(last_msg_->stub[6], 1) + << "incorrect value for stub[6], expected 1, is " << last_msg_->stub[6]; + EXPECT_EQ(last_msg_->stub[7], 2) + << "incorrect value for stub[7], expected 2, is " << last_msg_->stub[7]; + EXPECT_EQ(last_msg_->stub[8], 3) + << "incorrect value for stub[8], expected 3, is " << last_msg_->stub[8]; + EXPECT_EQ(last_msg_->stub[9], 4) + << "incorrect value for stub[9], expected 4, is " << last_msg_->stub[9]; + EXPECT_EQ(last_msg_->stub[10], 0) + << "incorrect value for stub[10], expected 0, is " << last_msg_->stub[10]; + EXPECT_EQ(last_msg_->stub[11], 5) + << "incorrect value for stub[11], expected 5, is " << last_msg_->stub[11]; + EXPECT_EQ(last_msg_->stub[12], 0) + << "incorrect value for stub[12], expected 0, is " << last_msg_->stub[12]; + EXPECT_EQ(last_msg_->stub[13], 6) + << "incorrect value for stub[13], expected 6, is " << last_msg_->stub[13]; + EXPECT_EQ(last_msg_->stub[14], 30) + << "incorrect value for stub[14], expected 30, is " + << last_msg_->stub[14]; + EXPECT_EQ(last_msg_->stub[15], 0) + << "incorrect value for stub[15], expected 0, is " << last_msg_->stub[15]; + EXPECT_EQ(last_msg_->stub[16], 2) + << "incorrect value for stub[16], expected 2, is " << last_msg_->stub[16]; + EXPECT_EQ(last_msg_->stub[17], 10) + << "incorrect value for stub[17], expected 10, is " + << last_msg_->stub[17]; + EXPECT_EQ(last_msg_->stub[18], 11) + << "incorrect value for stub[18], expected 11, is " + << last_msg_->stub[18]; + EXPECT_EQ(last_msg_->stub[19], 15) + << "incorrect value for stub[19], expected 15, is " + << last_msg_->stub[19]; + EXPECT_EQ(last_msg_->stub[20], 14) + << "incorrect value for stub[20], expected 14, is " + << last_msg_->stub[20]; +} diff --git a/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints.cc b/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints.cc new file mode 100644 index 0000000000..3417f1c682 --- /dev/null +++ b/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints.cc @@ -0,0 +1,254 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPoints.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +class Test_legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::PayloadHandler { + public: + Test_legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::PayloadHandler(this), + last_msg_storage_(), + last_msg_(reinterpret_cast( + last_msg_storage_)), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, uint8_t message_length, + const msg_ssr_flag_iono_grid_points_t &msg) override { + memcpy(last_msg_storage_, &msg, message_length); + last_msg_len_ = message_length; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + uint8_t last_msg_storage_[SBP_MAX_PAYLOAD_LEN]; + msg_ssr_flag_iono_grid_points_t *last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_legacy_auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints0, Test) { + uint8_t encoded_frame[] = { + 85, 199, 11, 66, 0, 21, 180, 0, 0, 0, 3, 0, 1, 2, 3, + 4, 0, 5, 0, 6, 3, 10, 0, 11, 0, 12, 0, 53, 7, + }; + + uint8_t test_msg_storage[SBP_MAX_PAYLOAD_LEN]{}; + uint8_t test_msg_len = 0; + msg_ssr_flag_iono_grid_points_t *test_msg = + (msg_ssr_flag_iono_grid_points_t *)test_msg_storage; + test_msg_len = (uint8_t)sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[7] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[8] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[9] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[10] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[11] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[12] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[13] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[14] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[15] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[16] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[17] = 11; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[18] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[19] = 12; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[20] = 0; + + EXPECT_EQ(send_message(3015, 66, test_msg_len, test_msg_storage), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_len_, test_msg_len); + EXPECT_EQ(last_msg_->stub[0], 180) + << "incorrect value for stub[0], expected 180, is " << last_msg_->stub[0]; + EXPECT_EQ(last_msg_->stub[1], 0) + << "incorrect value for stub[1], expected 0, is " << last_msg_->stub[1]; + EXPECT_EQ(last_msg_->stub[2], 0) + << "incorrect value for stub[2], expected 0, is " << last_msg_->stub[2]; + EXPECT_EQ(last_msg_->stub[3], 0) + << "incorrect value for stub[3], expected 0, is " << last_msg_->stub[3]; + EXPECT_EQ(last_msg_->stub[4], 3) + << "incorrect value for stub[4], expected 3, is " << last_msg_->stub[4]; + EXPECT_EQ(last_msg_->stub[5], 0) + << "incorrect value for stub[5], expected 0, is " << last_msg_->stub[5]; + EXPECT_EQ(last_msg_->stub[6], 1) + << "incorrect value for stub[6], expected 1, is " << last_msg_->stub[6]; + EXPECT_EQ(last_msg_->stub[7], 2) + << "incorrect value for stub[7], expected 2, is " << last_msg_->stub[7]; + EXPECT_EQ(last_msg_->stub[8], 3) + << "incorrect value for stub[8], expected 3, is " << last_msg_->stub[8]; + EXPECT_EQ(last_msg_->stub[9], 4) + << "incorrect value for stub[9], expected 4, is " << last_msg_->stub[9]; + EXPECT_EQ(last_msg_->stub[10], 0) + << "incorrect value for stub[10], expected 0, is " << last_msg_->stub[10]; + EXPECT_EQ(last_msg_->stub[11], 5) + << "incorrect value for stub[11], expected 5, is " << last_msg_->stub[11]; + EXPECT_EQ(last_msg_->stub[12], 0) + << "incorrect value for stub[12], expected 0, is " << last_msg_->stub[12]; + EXPECT_EQ(last_msg_->stub[13], 6) + << "incorrect value for stub[13], expected 6, is " << last_msg_->stub[13]; + EXPECT_EQ(last_msg_->stub[14], 3) + << "incorrect value for stub[14], expected 3, is " << last_msg_->stub[14]; + EXPECT_EQ(last_msg_->stub[15], 10) + << "incorrect value for stub[15], expected 10, is " + << last_msg_->stub[15]; + EXPECT_EQ(last_msg_->stub[16], 0) + << "incorrect value for stub[16], expected 0, is " << last_msg_->stub[16]; + EXPECT_EQ(last_msg_->stub[17], 11) + << "incorrect value for stub[17], expected 11, is " + << last_msg_->stub[17]; + EXPECT_EQ(last_msg_->stub[18], 0) + << "incorrect value for stub[18], expected 0, is " << last_msg_->stub[18]; + EXPECT_EQ(last_msg_->stub[19], 12) + << "incorrect value for stub[19], expected 12, is " + << last_msg_->stub[19]; + EXPECT_EQ(last_msg_->stub[20], 0) + << "incorrect value for stub[20], expected 0, is " << last_msg_->stub[20]; +} diff --git a/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos.cc b/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos.cc new file mode 100644 index 0000000000..0d5fff7a47 --- /dev/null +++ b/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos.cc @@ -0,0 +1,241 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoTileSatLos.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +class Test_legacy_auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::PayloadHandler { + public: + Test_legacy_auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::PayloadHandler(this), + last_msg_storage_(), + last_msg_(reinterpret_cast( + last_msg_storage_)), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, uint8_t message_length, + const msg_ssr_flag_iono_tile_sat_los_t &msg) override { + memcpy(last_msg_storage_, &msg, message_length); + last_msg_len_ = message_length; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + uint8_t last_msg_storage_[SBP_MAX_PAYLOAD_LEN]; + msg_ssr_flag_iono_tile_sat_los_t *last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_legacy_auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos0, Test) { + uint8_t encoded_frame[] = { + 85, 205, 11, 66, 0, 19, 180, 0, 0, 0, 3, 0, 1, 2, + 3, 4, 0, 5, 0, 6, 2, 10, 11, 15, 14, 239, 235, + }; + + uint8_t test_msg_storage[SBP_MAX_PAYLOAD_LEN]{}; + uint8_t test_msg_len = 0; + msg_ssr_flag_iono_tile_sat_los_t *test_msg = + (msg_ssr_flag_iono_tile_sat_los_t *)test_msg_storage; + test_msg_len = (uint8_t)sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[7] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[8] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[9] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[10] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[11] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[12] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[13] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[14] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[15] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[16] = 11; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[17] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[18] = 14; + + EXPECT_EQ(send_message(3021, 66, test_msg_len, test_msg_storage), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_len_, test_msg_len); + EXPECT_EQ(last_msg_->stub[0], 180) + << "incorrect value for stub[0], expected 180, is " << last_msg_->stub[0]; + EXPECT_EQ(last_msg_->stub[1], 0) + << "incorrect value for stub[1], expected 0, is " << last_msg_->stub[1]; + EXPECT_EQ(last_msg_->stub[2], 0) + << "incorrect value for stub[2], expected 0, is " << last_msg_->stub[2]; + EXPECT_EQ(last_msg_->stub[3], 0) + << "incorrect value for stub[3], expected 0, is " << last_msg_->stub[3]; + EXPECT_EQ(last_msg_->stub[4], 3) + << "incorrect value for stub[4], expected 3, is " << last_msg_->stub[4]; + EXPECT_EQ(last_msg_->stub[5], 0) + << "incorrect value for stub[5], expected 0, is " << last_msg_->stub[5]; + EXPECT_EQ(last_msg_->stub[6], 1) + << "incorrect value for stub[6], expected 1, is " << last_msg_->stub[6]; + EXPECT_EQ(last_msg_->stub[7], 2) + << "incorrect value for stub[7], expected 2, is " << last_msg_->stub[7]; + EXPECT_EQ(last_msg_->stub[8], 3) + << "incorrect value for stub[8], expected 3, is " << last_msg_->stub[8]; + EXPECT_EQ(last_msg_->stub[9], 4) + << "incorrect value for stub[9], expected 4, is " << last_msg_->stub[9]; + EXPECT_EQ(last_msg_->stub[10], 0) + << "incorrect value for stub[10], expected 0, is " << last_msg_->stub[10]; + EXPECT_EQ(last_msg_->stub[11], 5) + << "incorrect value for stub[11], expected 5, is " << last_msg_->stub[11]; + EXPECT_EQ(last_msg_->stub[12], 0) + << "incorrect value for stub[12], expected 0, is " << last_msg_->stub[12]; + EXPECT_EQ(last_msg_->stub[13], 6) + << "incorrect value for stub[13], expected 6, is " << last_msg_->stub[13]; + EXPECT_EQ(last_msg_->stub[14], 2) + << "incorrect value for stub[14], expected 2, is " << last_msg_->stub[14]; + EXPECT_EQ(last_msg_->stub[15], 10) + << "incorrect value for stub[15], expected 10, is " + << last_msg_->stub[15]; + EXPECT_EQ(last_msg_->stub[16], 11) + << "incorrect value for stub[16], expected 11, is " + << last_msg_->stub[16]; + EXPECT_EQ(last_msg_->stub[17], 15) + << "incorrect value for stub[17], expected 15, is " + << last_msg_->stub[17]; + EXPECT_EQ(last_msg_->stub[18], 14) + << "incorrect value for stub[18], expected 14, is " + << last_msg_->stub[18]; +} diff --git a/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagSatellites.cc b/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagSatellites.cc new file mode 100644 index 0000000000..bafc81216d --- /dev/null +++ b/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagSatellites.cc @@ -0,0 +1,212 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagSatellites.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +class Test_legacy_auto_check_sbp_integrity_MsgSsrFlagSatellites0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::PayloadHandler { + public: + Test_legacy_auto_check_sbp_integrity_MsgSsrFlagSatellites0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::PayloadHandler(this), + last_msg_storage_(), + last_msg_( + reinterpret_cast(last_msg_storage_)), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, uint8_t message_length, + const msg_ssr_flag_satellites_t &msg) override { + memcpy(last_msg_storage_, &msg, message_length); + last_msg_len_ = message_length; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + uint8_t last_msg_storage_[SBP_MAX_PAYLOAD_LEN]; + msg_ssr_flag_satellites_t *last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_legacy_auto_check_sbp_integrity_MsgSsrFlagSatellites0, Test) { + uint8_t encoded_frame[] = { + 85, 189, 11, 66, 0, 15, 180, 0, 0, 0, 3, 0, + 1, 2, 3, 4, 5, 3, 10, 11, 12, 110, 165, + }; + + uint8_t test_msg_storage[SBP_MAX_PAYLOAD_LEN]{}; + uint8_t test_msg_len = 0; + msg_ssr_flag_satellites_t *test_msg = + (msg_ssr_flag_satellites_t *)test_msg_storage; + test_msg_len = (uint8_t)sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[7] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[8] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[9] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[10] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[11] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[12] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[13] = 11; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[14] = 12; + + EXPECT_EQ(send_message(3005, 66, test_msg_len, test_msg_storage), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_len_, test_msg_len); + EXPECT_EQ(last_msg_->stub[0], 180) + << "incorrect value for stub[0], expected 180, is " << last_msg_->stub[0]; + EXPECT_EQ(last_msg_->stub[1], 0) + << "incorrect value for stub[1], expected 0, is " << last_msg_->stub[1]; + EXPECT_EQ(last_msg_->stub[2], 0) + << "incorrect value for stub[2], expected 0, is " << last_msg_->stub[2]; + EXPECT_EQ(last_msg_->stub[3], 0) + << "incorrect value for stub[3], expected 0, is " << last_msg_->stub[3]; + EXPECT_EQ(last_msg_->stub[4], 3) + << "incorrect value for stub[4], expected 3, is " << last_msg_->stub[4]; + EXPECT_EQ(last_msg_->stub[5], 0) + << "incorrect value for stub[5], expected 0, is " << last_msg_->stub[5]; + EXPECT_EQ(last_msg_->stub[6], 1) + << "incorrect value for stub[6], expected 1, is " << last_msg_->stub[6]; + EXPECT_EQ(last_msg_->stub[7], 2) + << "incorrect value for stub[7], expected 2, is " << last_msg_->stub[7]; + EXPECT_EQ(last_msg_->stub[8], 3) + << "incorrect value for stub[8], expected 3, is " << last_msg_->stub[8]; + EXPECT_EQ(last_msg_->stub[9], 4) + << "incorrect value for stub[9], expected 4, is " << last_msg_->stub[9]; + EXPECT_EQ(last_msg_->stub[10], 5) + << "incorrect value for stub[10], expected 5, is " << last_msg_->stub[10]; + EXPECT_EQ(last_msg_->stub[11], 3) + << "incorrect value for stub[11], expected 3, is " << last_msg_->stub[11]; + EXPECT_EQ(last_msg_->stub[12], 10) + << "incorrect value for stub[12], expected 10, is " + << last_msg_->stub[12]; + EXPECT_EQ(last_msg_->stub[13], 11) + << "incorrect value for stub[13], expected 11, is " + << last_msg_->stub[13]; + EXPECT_EQ(last_msg_->stub[14], 12) + << "incorrect value for stub[14], expected 12, is " + << last_msg_->stub[14]; +} diff --git a/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints.cc b/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints.cc new file mode 100644 index 0000000000..f539e9b19f --- /dev/null +++ b/c/test/legacy/cpp/auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints.cc @@ -0,0 +1,254 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagTropoGridPoints.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +class Test_legacy_auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::PayloadHandler { + public: + Test_legacy_auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::PayloadHandler(this), + last_msg_storage_(), + last_msg_(reinterpret_cast( + last_msg_storage_)), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, uint8_t message_length, + const msg_ssr_flag_tropo_grid_points_t &msg) override { + memcpy(last_msg_storage_, &msg, message_length); + last_msg_len_ = message_length; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + uint8_t last_msg_storage_[SBP_MAX_PAYLOAD_LEN]; + msg_ssr_flag_tropo_grid_points_t *last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_legacy_auto_check_sbp_integrity_MsgSsrFlagTropoGridPoints0, Test) { + uint8_t encoded_frame[] = { + 85, 195, 11, 66, 0, 21, 180, 0, 0, 0, 3, 0, 1, 2, 3, + 4, 0, 5, 0, 6, 3, 10, 0, 11, 0, 12, 0, 243, 150, + }; + + uint8_t test_msg_storage[SBP_MAX_PAYLOAD_LEN]{}; + uint8_t test_msg_len = 0; + msg_ssr_flag_tropo_grid_points_t *test_msg = + (msg_ssr_flag_tropo_grid_points_t *)test_msg_storage; + test_msg_len = (uint8_t)sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[7] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[8] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[9] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[10] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[11] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[12] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[13] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[14] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[15] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[16] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[17] = 11; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[18] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[19] = 12; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[20] = 0; + + EXPECT_EQ(send_message(3011, 66, test_msg_len, test_msg_storage), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_len_, test_msg_len); + EXPECT_EQ(last_msg_->stub[0], 180) + << "incorrect value for stub[0], expected 180, is " << last_msg_->stub[0]; + EXPECT_EQ(last_msg_->stub[1], 0) + << "incorrect value for stub[1], expected 0, is " << last_msg_->stub[1]; + EXPECT_EQ(last_msg_->stub[2], 0) + << "incorrect value for stub[2], expected 0, is " << last_msg_->stub[2]; + EXPECT_EQ(last_msg_->stub[3], 0) + << "incorrect value for stub[3], expected 0, is " << last_msg_->stub[3]; + EXPECT_EQ(last_msg_->stub[4], 3) + << "incorrect value for stub[4], expected 3, is " << last_msg_->stub[4]; + EXPECT_EQ(last_msg_->stub[5], 0) + << "incorrect value for stub[5], expected 0, is " << last_msg_->stub[5]; + EXPECT_EQ(last_msg_->stub[6], 1) + << "incorrect value for stub[6], expected 1, is " << last_msg_->stub[6]; + EXPECT_EQ(last_msg_->stub[7], 2) + << "incorrect value for stub[7], expected 2, is " << last_msg_->stub[7]; + EXPECT_EQ(last_msg_->stub[8], 3) + << "incorrect value for stub[8], expected 3, is " << last_msg_->stub[8]; + EXPECT_EQ(last_msg_->stub[9], 4) + << "incorrect value for stub[9], expected 4, is " << last_msg_->stub[9]; + EXPECT_EQ(last_msg_->stub[10], 0) + << "incorrect value for stub[10], expected 0, is " << last_msg_->stub[10]; + EXPECT_EQ(last_msg_->stub[11], 5) + << "incorrect value for stub[11], expected 5, is " << last_msg_->stub[11]; + EXPECT_EQ(last_msg_->stub[12], 0) + << "incorrect value for stub[12], expected 0, is " << last_msg_->stub[12]; + EXPECT_EQ(last_msg_->stub[13], 6) + << "incorrect value for stub[13], expected 6, is " << last_msg_->stub[13]; + EXPECT_EQ(last_msg_->stub[14], 3) + << "incorrect value for stub[14], expected 3, is " << last_msg_->stub[14]; + EXPECT_EQ(last_msg_->stub[15], 10) + << "incorrect value for stub[15], expected 10, is " + << last_msg_->stub[15]; + EXPECT_EQ(last_msg_->stub[16], 0) + << "incorrect value for stub[16], expected 0, is " << last_msg_->stub[16]; + EXPECT_EQ(last_msg_->stub[17], 11) + << "incorrect value for stub[17], expected 11, is " + << last_msg_->stub[17]; + EXPECT_EQ(last_msg_->stub[18], 0) + << "incorrect value for stub[18], expected 0, is " << last_msg_->stub[18]; + EXPECT_EQ(last_msg_->stub[19], 12) + << "incorrect value for stub[19], expected 12, is " + << last_msg_->stub[19]; + EXPECT_EQ(last_msg_->stub[20], 0) + << "incorrect value for stub[20], expected 0, is " << last_msg_->stub[20]; +} diff --git a/c/test/legacy/cpp/auto_check_sbp_navigation_MsgGPSLeapSecond.cc b/c/test/legacy/cpp/auto_check_sbp_navigation_MsgGPSLeapSecond.cc new file mode 100644 index 0000000000..7754bdc0dd --- /dev/null +++ b/c/test/legacy/cpp/auto_check_sbp_navigation_MsgGPSLeapSecond.cc @@ -0,0 +1,199 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSLeapSecond.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +class Test_legacy_auto_check_sbp_navigation_MsgGPSLeapSecond0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::PayloadHandler { + public: + Test_legacy_auto_check_sbp_navigation_MsgGPSLeapSecond0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::PayloadHandler(this), + last_msg_storage_(), + last_msg_(reinterpret_cast(last_msg_storage_)), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, uint8_t message_length, + const msg_gps_leap_second_t &msg) override { + memcpy(last_msg_storage_, &msg, message_length); + last_msg_len_ = message_length; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + uint8_t last_msg_storage_[SBP_MAX_PAYLOAD_LEN]; + msg_gps_leap_second_t *last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_legacy_auto_check_sbp_navigation_MsgGPSLeapSecond0, Test) { + uint8_t encoded_frame[] = { + 85, 58, 2, 66, 0, 14, 1, 0, 2, 0, 3, 4, 5, 0, 6, 0, 7, 0, 8, 9, 50, 232, + }; + + uint8_t test_msg_storage[SBP_MAX_PAYLOAD_LEN]{}; + uint8_t test_msg_len = 0; + msg_gps_leap_second_t *test_msg = (msg_gps_leap_second_t *)test_msg_storage; + test_msg_len = (uint8_t)sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[0] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[2] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[5] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[6] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[7] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[8] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[9] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[10] = 7; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[11] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[12] = 8; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[13] = 9; + + EXPECT_EQ(send_message(570, 66, test_msg_len, test_msg_storage), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_len_, test_msg_len); + EXPECT_EQ(last_msg_->stub[0], 1) + << "incorrect value for stub[0], expected 1, is " << last_msg_->stub[0]; + EXPECT_EQ(last_msg_->stub[1], 0) + << "incorrect value for stub[1], expected 0, is " << last_msg_->stub[1]; + EXPECT_EQ(last_msg_->stub[2], 2) + << "incorrect value for stub[2], expected 2, is " << last_msg_->stub[2]; + EXPECT_EQ(last_msg_->stub[3], 0) + << "incorrect value for stub[3], expected 0, is " << last_msg_->stub[3]; + EXPECT_EQ(last_msg_->stub[4], 3) + << "incorrect value for stub[4], expected 3, is " << last_msg_->stub[4]; + EXPECT_EQ(last_msg_->stub[5], 4) + << "incorrect value for stub[5], expected 4, is " << last_msg_->stub[5]; + EXPECT_EQ(last_msg_->stub[6], 5) + << "incorrect value for stub[6], expected 5, is " << last_msg_->stub[6]; + EXPECT_EQ(last_msg_->stub[7], 0) + << "incorrect value for stub[7], expected 0, is " << last_msg_->stub[7]; + EXPECT_EQ(last_msg_->stub[8], 6) + << "incorrect value for stub[8], expected 6, is " << last_msg_->stub[8]; + EXPECT_EQ(last_msg_->stub[9], 0) + << "incorrect value for stub[9], expected 0, is " << last_msg_->stub[9]; + EXPECT_EQ(last_msg_->stub[10], 7) + << "incorrect value for stub[10], expected 7, is " << last_msg_->stub[10]; + EXPECT_EQ(last_msg_->stub[11], 0) + << "incorrect value for stub[11], expected 0, is " << last_msg_->stub[11]; + EXPECT_EQ(last_msg_->stub[12], 8) + << "incorrect value for stub[12], expected 8, is " << last_msg_->stub[12]; + EXPECT_EQ(last_msg_->stub[13], 9) + << "incorrect value for stub[13], expected 9, is " << last_msg_->stub[13]; +} diff --git a/c/test/legacy/cpp/auto_check_sbp_navigation_MsgItrf.cc b/c/test/legacy/cpp/auto_check_sbp_navigation_MsgItrf.cc new file mode 100644 index 0000000000..4c33c4e92e --- /dev/null +++ b/c/test/legacy/cpp/auto_check_sbp_navigation_MsgItrf.cc @@ -0,0 +1,1008 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml by generate.py. Do +// not modify by hand! + +#include +#include +#include +#include +class Test_legacy_auto_check_sbp_navigation_MsgItrf0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::PayloadHandler { + public: + Test_legacy_auto_check_sbp_navigation_MsgItrf0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::PayloadHandler(this), + last_msg_storage_(), + last_msg_(reinterpret_cast(last_msg_storage_)), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, uint8_t message_length, + const msg_itrf_t &msg) override { + memcpy(last_msg_storage_, &msg, message_length); + last_msg_len_ = message_length; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + uint8_t last_msg_storage_[SBP_MAX_PAYLOAD_LEN]; + msg_itrf_t *last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_legacy_auto_check_sbp_navigation_MsgItrf0, Test) { + uint8_t encoded_frame[] = { + 85, 68, 2, 66, 0, 124, 1, 2, 102, 111, 111, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 98, 97, 114, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 5, 0, 6, 0, 7, 0, 0, 0, 8, 0, 0, 0, 9, + 0, 0, 0, 10, 0, 0, 0, 11, 0, 0, 0, 12, 0, 0, 0, 13, 0, + 0, 0, 14, 0, 0, 0, 15, 0, 0, 0, 16, 0, 0, 0, 17, 0, 0, + 0, 18, 0, 0, 0, 19, 0, 0, 0, 20, 0, 66, 126, + }; + + uint8_t test_msg_storage[SBP_MAX_PAYLOAD_LEN]{}; + uint8_t test_msg_len = 0; + msg_itrf_t *test_msg = (msg_itrf_t *)test_msg_storage; + test_msg_len = (uint8_t)sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[0] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[1] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[2] = 102; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[3] = 111; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[4] = 111; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[6] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[7] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[8] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[9] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[10] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[11] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[12] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[13] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[14] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[15] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[16] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[17] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[18] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[19] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[20] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[21] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[22] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[23] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[24] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[25] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[26] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[27] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[28] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[29] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[30] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[31] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[32] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[33] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[34] = 98; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[35] = 97; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[36] = 114; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[37] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[38] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[39] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[40] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[41] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[42] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[43] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[44] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[45] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[46] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[47] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[48] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[49] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[50] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[51] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[52] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[53] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[54] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[55] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[56] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[57] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[58] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[59] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[60] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[61] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[62] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[63] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[64] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[65] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[66] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[67] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[68] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[69] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[70] = 7; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[71] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[72] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[73] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[74] = 8; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[75] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[76] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[77] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[78] = 9; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[79] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[80] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[81] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[82] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[83] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[84] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[85] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[86] = 11; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[87] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[88] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[89] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[90] = 12; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[91] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[92] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[93] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[94] = 13; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[95] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[96] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[97] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[98] = 14; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[99] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[100] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[101] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[102] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[103] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[104] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[105] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[106] = 16; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[107] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[108] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[109] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[110] = 17; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[111] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[112] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[113] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[114] = 18; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[115] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[116] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[117] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[118] = 19; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[119] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[120] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[121] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[122] = 20; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[123] = 0; + + EXPECT_EQ(send_message(580, 66, test_msg_len, test_msg_storage), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_len_, test_msg_len); + EXPECT_EQ(last_msg_->stub[0], 1) + << "incorrect value for stub[0], expected 1, is " << last_msg_->stub[0]; + EXPECT_EQ(last_msg_->stub[1], 2) + << "incorrect value for stub[1], expected 2, is " << last_msg_->stub[1]; + EXPECT_EQ(last_msg_->stub[2], 102) + << "incorrect value for stub[2], expected 102, is " << last_msg_->stub[2]; + EXPECT_EQ(last_msg_->stub[3], 111) + << "incorrect value for stub[3], expected 111, is " << last_msg_->stub[3]; + EXPECT_EQ(last_msg_->stub[4], 111) + << "incorrect value for stub[4], expected 111, is " << last_msg_->stub[4]; + EXPECT_EQ(last_msg_->stub[5], 0) + << "incorrect value for stub[5], expected 0, is " << last_msg_->stub[5]; + EXPECT_EQ(last_msg_->stub[6], 0) + << "incorrect value for stub[6], expected 0, is " << last_msg_->stub[6]; + EXPECT_EQ(last_msg_->stub[7], 0) + << "incorrect value for stub[7], expected 0, is " << last_msg_->stub[7]; + EXPECT_EQ(last_msg_->stub[8], 0) + << "incorrect value for stub[8], expected 0, is " << last_msg_->stub[8]; + EXPECT_EQ(last_msg_->stub[9], 0) + << "incorrect value for stub[9], expected 0, is " << last_msg_->stub[9]; + EXPECT_EQ(last_msg_->stub[10], 0) + << "incorrect value for stub[10], expected 0, is " << last_msg_->stub[10]; + EXPECT_EQ(last_msg_->stub[11], 0) + << "incorrect value for stub[11], expected 0, is " << last_msg_->stub[11]; + EXPECT_EQ(last_msg_->stub[12], 0) + << "incorrect value for stub[12], expected 0, is " << last_msg_->stub[12]; + EXPECT_EQ(last_msg_->stub[13], 0) + << "incorrect value for stub[13], expected 0, is " << last_msg_->stub[13]; + EXPECT_EQ(last_msg_->stub[14], 0) + << "incorrect value for stub[14], expected 0, is " << last_msg_->stub[14]; + EXPECT_EQ(last_msg_->stub[15], 0) + << "incorrect value for stub[15], expected 0, is " << last_msg_->stub[15]; + EXPECT_EQ(last_msg_->stub[16], 0) + << "incorrect value for stub[16], expected 0, is " << last_msg_->stub[16]; + EXPECT_EQ(last_msg_->stub[17], 0) + << "incorrect value for stub[17], expected 0, is " << last_msg_->stub[17]; + EXPECT_EQ(last_msg_->stub[18], 0) + << "incorrect value for stub[18], expected 0, is " << last_msg_->stub[18]; + EXPECT_EQ(last_msg_->stub[19], 0) + << "incorrect value for stub[19], expected 0, is " << last_msg_->stub[19]; + EXPECT_EQ(last_msg_->stub[20], 0) + << "incorrect value for stub[20], expected 0, is " << last_msg_->stub[20]; + EXPECT_EQ(last_msg_->stub[21], 0) + << "incorrect value for stub[21], expected 0, is " << last_msg_->stub[21]; + EXPECT_EQ(last_msg_->stub[22], 0) + << "incorrect value for stub[22], expected 0, is " << last_msg_->stub[22]; + EXPECT_EQ(last_msg_->stub[23], 0) + << "incorrect value for stub[23], expected 0, is " << last_msg_->stub[23]; + EXPECT_EQ(last_msg_->stub[24], 0) + << "incorrect value for stub[24], expected 0, is " << last_msg_->stub[24]; + EXPECT_EQ(last_msg_->stub[25], 0) + << "incorrect value for stub[25], expected 0, is " << last_msg_->stub[25]; + EXPECT_EQ(last_msg_->stub[26], 0) + << "incorrect value for stub[26], expected 0, is " << last_msg_->stub[26]; + EXPECT_EQ(last_msg_->stub[27], 0) + << "incorrect value for stub[27], expected 0, is " << last_msg_->stub[27]; + EXPECT_EQ(last_msg_->stub[28], 0) + << "incorrect value for stub[28], expected 0, is " << last_msg_->stub[28]; + EXPECT_EQ(last_msg_->stub[29], 0) + << "incorrect value for stub[29], expected 0, is " << last_msg_->stub[29]; + EXPECT_EQ(last_msg_->stub[30], 0) + << "incorrect value for stub[30], expected 0, is " << last_msg_->stub[30]; + EXPECT_EQ(last_msg_->stub[31], 0) + << "incorrect value for stub[31], expected 0, is " << last_msg_->stub[31]; + EXPECT_EQ(last_msg_->stub[32], 0) + << "incorrect value for stub[32], expected 0, is " << last_msg_->stub[32]; + EXPECT_EQ(last_msg_->stub[33], 3) + << "incorrect value for stub[33], expected 3, is " << last_msg_->stub[33]; + EXPECT_EQ(last_msg_->stub[34], 98) + << "incorrect value for stub[34], expected 98, is " + << last_msg_->stub[34]; + EXPECT_EQ(last_msg_->stub[35], 97) + << "incorrect value for stub[35], expected 97, is " + << last_msg_->stub[35]; + EXPECT_EQ(last_msg_->stub[36], 114) + << "incorrect value for stub[36], expected 114, is " + << last_msg_->stub[36]; + EXPECT_EQ(last_msg_->stub[37], 0) + << "incorrect value for stub[37], expected 0, is " << last_msg_->stub[37]; + EXPECT_EQ(last_msg_->stub[38], 0) + << "incorrect value for stub[38], expected 0, is " << last_msg_->stub[38]; + EXPECT_EQ(last_msg_->stub[39], 0) + << "incorrect value for stub[39], expected 0, is " << last_msg_->stub[39]; + EXPECT_EQ(last_msg_->stub[40], 0) + << "incorrect value for stub[40], expected 0, is " << last_msg_->stub[40]; + EXPECT_EQ(last_msg_->stub[41], 0) + << "incorrect value for stub[41], expected 0, is " << last_msg_->stub[41]; + EXPECT_EQ(last_msg_->stub[42], 0) + << "incorrect value for stub[42], expected 0, is " << last_msg_->stub[42]; + EXPECT_EQ(last_msg_->stub[43], 0) + << "incorrect value for stub[43], expected 0, is " << last_msg_->stub[43]; + EXPECT_EQ(last_msg_->stub[44], 0) + << "incorrect value for stub[44], expected 0, is " << last_msg_->stub[44]; + EXPECT_EQ(last_msg_->stub[45], 0) + << "incorrect value for stub[45], expected 0, is " << last_msg_->stub[45]; + EXPECT_EQ(last_msg_->stub[46], 0) + << "incorrect value for stub[46], expected 0, is " << last_msg_->stub[46]; + EXPECT_EQ(last_msg_->stub[47], 0) + << "incorrect value for stub[47], expected 0, is " << last_msg_->stub[47]; + EXPECT_EQ(last_msg_->stub[48], 0) + << "incorrect value for stub[48], expected 0, is " << last_msg_->stub[48]; + EXPECT_EQ(last_msg_->stub[49], 0) + << "incorrect value for stub[49], expected 0, is " << last_msg_->stub[49]; + EXPECT_EQ(last_msg_->stub[50], 0) + << "incorrect value for stub[50], expected 0, is " << last_msg_->stub[50]; + EXPECT_EQ(last_msg_->stub[51], 0) + << "incorrect value for stub[51], expected 0, is " << last_msg_->stub[51]; + EXPECT_EQ(last_msg_->stub[52], 0) + << "incorrect value for stub[52], expected 0, is " << last_msg_->stub[52]; + EXPECT_EQ(last_msg_->stub[53], 0) + << "incorrect value for stub[53], expected 0, is " << last_msg_->stub[53]; + EXPECT_EQ(last_msg_->stub[54], 0) + << "incorrect value for stub[54], expected 0, is " << last_msg_->stub[54]; + EXPECT_EQ(last_msg_->stub[55], 0) + << "incorrect value for stub[55], expected 0, is " << last_msg_->stub[55]; + EXPECT_EQ(last_msg_->stub[56], 0) + << "incorrect value for stub[56], expected 0, is " << last_msg_->stub[56]; + EXPECT_EQ(last_msg_->stub[57], 0) + << "incorrect value for stub[57], expected 0, is " << last_msg_->stub[57]; + EXPECT_EQ(last_msg_->stub[58], 0) + << "incorrect value for stub[58], expected 0, is " << last_msg_->stub[58]; + EXPECT_EQ(last_msg_->stub[59], 0) + << "incorrect value for stub[59], expected 0, is " << last_msg_->stub[59]; + EXPECT_EQ(last_msg_->stub[60], 0) + << "incorrect value for stub[60], expected 0, is " << last_msg_->stub[60]; + EXPECT_EQ(last_msg_->stub[61], 0) + << "incorrect value for stub[61], expected 0, is " << last_msg_->stub[61]; + EXPECT_EQ(last_msg_->stub[62], 0) + << "incorrect value for stub[62], expected 0, is " << last_msg_->stub[62]; + EXPECT_EQ(last_msg_->stub[63], 0) + << "incorrect value for stub[63], expected 0, is " << last_msg_->stub[63]; + EXPECT_EQ(last_msg_->stub[64], 0) + << "incorrect value for stub[64], expected 0, is " << last_msg_->stub[64]; + EXPECT_EQ(last_msg_->stub[65], 4) + << "incorrect value for stub[65], expected 4, is " << last_msg_->stub[65]; + EXPECT_EQ(last_msg_->stub[66], 5) + << "incorrect value for stub[66], expected 5, is " << last_msg_->stub[66]; + EXPECT_EQ(last_msg_->stub[67], 0) + << "incorrect value for stub[67], expected 0, is " << last_msg_->stub[67]; + EXPECT_EQ(last_msg_->stub[68], 6) + << "incorrect value for stub[68], expected 6, is " << last_msg_->stub[68]; + EXPECT_EQ(last_msg_->stub[69], 0) + << "incorrect value for stub[69], expected 0, is " << last_msg_->stub[69]; + EXPECT_EQ(last_msg_->stub[70], 7) + << "incorrect value for stub[70], expected 7, is " << last_msg_->stub[70]; + EXPECT_EQ(last_msg_->stub[71], 0) + << "incorrect value for stub[71], expected 0, is " << last_msg_->stub[71]; + EXPECT_EQ(last_msg_->stub[72], 0) + << "incorrect value for stub[72], expected 0, is " << last_msg_->stub[72]; + EXPECT_EQ(last_msg_->stub[73], 0) + << "incorrect value for stub[73], expected 0, is " << last_msg_->stub[73]; + EXPECT_EQ(last_msg_->stub[74], 8) + << "incorrect value for stub[74], expected 8, is " << last_msg_->stub[74]; + EXPECT_EQ(last_msg_->stub[75], 0) + << "incorrect value for stub[75], expected 0, is " << last_msg_->stub[75]; + EXPECT_EQ(last_msg_->stub[76], 0) + << "incorrect value for stub[76], expected 0, is " << last_msg_->stub[76]; + EXPECT_EQ(last_msg_->stub[77], 0) + << "incorrect value for stub[77], expected 0, is " << last_msg_->stub[77]; + EXPECT_EQ(last_msg_->stub[78], 9) + << "incorrect value for stub[78], expected 9, is " << last_msg_->stub[78]; + EXPECT_EQ(last_msg_->stub[79], 0) + << "incorrect value for stub[79], expected 0, is " << last_msg_->stub[79]; + EXPECT_EQ(last_msg_->stub[80], 0) + << "incorrect value for stub[80], expected 0, is " << last_msg_->stub[80]; + EXPECT_EQ(last_msg_->stub[81], 0) + << "incorrect value for stub[81], expected 0, is " << last_msg_->stub[81]; + EXPECT_EQ(last_msg_->stub[82], 10) + << "incorrect value for stub[82], expected 10, is " + << last_msg_->stub[82]; + EXPECT_EQ(last_msg_->stub[83], 0) + << "incorrect value for stub[83], expected 0, is " << last_msg_->stub[83]; + EXPECT_EQ(last_msg_->stub[84], 0) + << "incorrect value for stub[84], expected 0, is " << last_msg_->stub[84]; + EXPECT_EQ(last_msg_->stub[85], 0) + << "incorrect value for stub[85], expected 0, is " << last_msg_->stub[85]; + EXPECT_EQ(last_msg_->stub[86], 11) + << "incorrect value for stub[86], expected 11, is " + << last_msg_->stub[86]; + EXPECT_EQ(last_msg_->stub[87], 0) + << "incorrect value for stub[87], expected 0, is " << last_msg_->stub[87]; + EXPECT_EQ(last_msg_->stub[88], 0) + << "incorrect value for stub[88], expected 0, is " << last_msg_->stub[88]; + EXPECT_EQ(last_msg_->stub[89], 0) + << "incorrect value for stub[89], expected 0, is " << last_msg_->stub[89]; + EXPECT_EQ(last_msg_->stub[90], 12) + << "incorrect value for stub[90], expected 12, is " + << last_msg_->stub[90]; + EXPECT_EQ(last_msg_->stub[91], 0) + << "incorrect value for stub[91], expected 0, is " << last_msg_->stub[91]; + EXPECT_EQ(last_msg_->stub[92], 0) + << "incorrect value for stub[92], expected 0, is " << last_msg_->stub[92]; + EXPECT_EQ(last_msg_->stub[93], 0) + << "incorrect value for stub[93], expected 0, is " << last_msg_->stub[93]; + EXPECT_EQ(last_msg_->stub[94], 13) + << "incorrect value for stub[94], expected 13, is " + << last_msg_->stub[94]; + EXPECT_EQ(last_msg_->stub[95], 0) + << "incorrect value for stub[95], expected 0, is " << last_msg_->stub[95]; + EXPECT_EQ(last_msg_->stub[96], 0) + << "incorrect value for stub[96], expected 0, is " << last_msg_->stub[96]; + EXPECT_EQ(last_msg_->stub[97], 0) + << "incorrect value for stub[97], expected 0, is " << last_msg_->stub[97]; + EXPECT_EQ(last_msg_->stub[98], 14) + << "incorrect value for stub[98], expected 14, is " + << last_msg_->stub[98]; + EXPECT_EQ(last_msg_->stub[99], 0) + << "incorrect value for stub[99], expected 0, is " << last_msg_->stub[99]; + EXPECT_EQ(last_msg_->stub[100], 0) + << "incorrect value for stub[100], expected 0, is " + << last_msg_->stub[100]; + EXPECT_EQ(last_msg_->stub[101], 0) + << "incorrect value for stub[101], expected 0, is " + << last_msg_->stub[101]; + EXPECT_EQ(last_msg_->stub[102], 15) + << "incorrect value for stub[102], expected 15, is " + << last_msg_->stub[102]; + EXPECT_EQ(last_msg_->stub[103], 0) + << "incorrect value for stub[103], expected 0, is " + << last_msg_->stub[103]; + EXPECT_EQ(last_msg_->stub[104], 0) + << "incorrect value for stub[104], expected 0, is " + << last_msg_->stub[104]; + EXPECT_EQ(last_msg_->stub[105], 0) + << "incorrect value for stub[105], expected 0, is " + << last_msg_->stub[105]; + EXPECT_EQ(last_msg_->stub[106], 16) + << "incorrect value for stub[106], expected 16, is " + << last_msg_->stub[106]; + EXPECT_EQ(last_msg_->stub[107], 0) + << "incorrect value for stub[107], expected 0, is " + << last_msg_->stub[107]; + EXPECT_EQ(last_msg_->stub[108], 0) + << "incorrect value for stub[108], expected 0, is " + << last_msg_->stub[108]; + EXPECT_EQ(last_msg_->stub[109], 0) + << "incorrect value for stub[109], expected 0, is " + << last_msg_->stub[109]; + EXPECT_EQ(last_msg_->stub[110], 17) + << "incorrect value for stub[110], expected 17, is " + << last_msg_->stub[110]; + EXPECT_EQ(last_msg_->stub[111], 0) + << "incorrect value for stub[111], expected 0, is " + << last_msg_->stub[111]; + EXPECT_EQ(last_msg_->stub[112], 0) + << "incorrect value for stub[112], expected 0, is " + << last_msg_->stub[112]; + EXPECT_EQ(last_msg_->stub[113], 0) + << "incorrect value for stub[113], expected 0, is " + << last_msg_->stub[113]; + EXPECT_EQ(last_msg_->stub[114], 18) + << "incorrect value for stub[114], expected 18, is " + << last_msg_->stub[114]; + EXPECT_EQ(last_msg_->stub[115], 0) + << "incorrect value for stub[115], expected 0, is " + << last_msg_->stub[115]; + EXPECT_EQ(last_msg_->stub[116], 0) + << "incorrect value for stub[116], expected 0, is " + << last_msg_->stub[116]; + EXPECT_EQ(last_msg_->stub[117], 0) + << "incorrect value for stub[117], expected 0, is " + << last_msg_->stub[117]; + EXPECT_EQ(last_msg_->stub[118], 19) + << "incorrect value for stub[118], expected 19, is " + << last_msg_->stub[118]; + EXPECT_EQ(last_msg_->stub[119], 0) + << "incorrect value for stub[119], expected 0, is " + << last_msg_->stub[119]; + EXPECT_EQ(last_msg_->stub[120], 0) + << "incorrect value for stub[120], expected 0, is " + << last_msg_->stub[120]; + EXPECT_EQ(last_msg_->stub[121], 0) + << "incorrect value for stub[121], expected 0, is " + << last_msg_->stub[121]; + EXPECT_EQ(last_msg_->stub[122], 20) + << "incorrect value for stub[122], expected 20, is " + << last_msg_->stub[122]; + EXPECT_EQ(last_msg_->stub[123], 0) + << "incorrect value for stub[123], expected 0, is " + << last_msg_->stub[123]; +} diff --git a/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds.cc b/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds.cc new file mode 100644 index 0000000000..e7493d3cd3 --- /dev/null +++ b/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds.cc @@ -0,0 +1,328 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrCodePhaseBiasesBounds.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +class Test_legacy_auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::PayloadHandler { + public: + Test_legacy_auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::PayloadHandler(this), + last_msg_storage_(), + last_msg_(reinterpret_cast( + last_msg_storage_)), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, uint8_t message_length, + const msg_ssr_code_phase_biases_bounds_t &msg) override { + memcpy(last_msg_storage_, &msg, message_length); + last_msg_len_ = message_length; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + uint8_t last_msg_storage_[SBP_MAX_PAYLOAD_LEN]; + msg_ssr_code_phase_biases_bounds_t *last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_legacy_auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBounds0, Test) { + uint8_t encoded_frame[] = { + 85, 236, 5, 66, 0, 31, 180, 0, 0, 0, 3, 0, 1, 2, 1, 14, 15, 1, 3, 0, + 3, 39, 1, 39, 1, 1, 3, 39, 1, 39, 1, 1, 1, 39, 1, 39, 1, 23, 113, + }; + + uint8_t test_msg_storage[SBP_MAX_PAYLOAD_LEN]{}; + uint8_t test_msg_len = 0; + msg_ssr_code_phase_biases_bounds_t *test_msg = + (msg_ssr_code_phase_biases_bounds_t *)test_msg_storage; + test_msg_len = (uint8_t)sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[7] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[8] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[9] = 14; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[10] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[11] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[12] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[13] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[14] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[15] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[16] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[17] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[18] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[19] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[20] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[21] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[22] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[23] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[24] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[25] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[26] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[27] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[28] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[29] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[30] = 1; + + EXPECT_EQ(send_message(1516, 66, test_msg_len, test_msg_storage), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_len_, test_msg_len); + EXPECT_EQ(last_msg_->stub[0], 180) + << "incorrect value for stub[0], expected 180, is " << last_msg_->stub[0]; + EXPECT_EQ(last_msg_->stub[1], 0) + << "incorrect value for stub[1], expected 0, is " << last_msg_->stub[1]; + EXPECT_EQ(last_msg_->stub[2], 0) + << "incorrect value for stub[2], expected 0, is " << last_msg_->stub[2]; + EXPECT_EQ(last_msg_->stub[3], 0) + << "incorrect value for stub[3], expected 0, is " << last_msg_->stub[3]; + EXPECT_EQ(last_msg_->stub[4], 3) + << "incorrect value for stub[4], expected 3, is " << last_msg_->stub[4]; + EXPECT_EQ(last_msg_->stub[5], 0) + << "incorrect value for stub[5], expected 0, is " << last_msg_->stub[5]; + EXPECT_EQ(last_msg_->stub[6], 1) + << "incorrect value for stub[6], expected 1, is " << last_msg_->stub[6]; + EXPECT_EQ(last_msg_->stub[7], 2) + << "incorrect value for stub[7], expected 2, is " << last_msg_->stub[7]; + EXPECT_EQ(last_msg_->stub[8], 1) + << "incorrect value for stub[8], expected 1, is " << last_msg_->stub[8]; + EXPECT_EQ(last_msg_->stub[9], 14) + << "incorrect value for stub[9], expected 14, is " << last_msg_->stub[9]; + EXPECT_EQ(last_msg_->stub[10], 15) + << "incorrect value for stub[10], expected 15, is " + << last_msg_->stub[10]; + EXPECT_EQ(last_msg_->stub[11], 1) + << "incorrect value for stub[11], expected 1, is " << last_msg_->stub[11]; + EXPECT_EQ(last_msg_->stub[12], 3) + << "incorrect value for stub[12], expected 3, is " << last_msg_->stub[12]; + EXPECT_EQ(last_msg_->stub[13], 0) + << "incorrect value for stub[13], expected 0, is " << last_msg_->stub[13]; + EXPECT_EQ(last_msg_->stub[14], 3) + << "incorrect value for stub[14], expected 3, is " << last_msg_->stub[14]; + EXPECT_EQ(last_msg_->stub[15], 39) + << "incorrect value for stub[15], expected 39, is " + << last_msg_->stub[15]; + EXPECT_EQ(last_msg_->stub[16], 1) + << "incorrect value for stub[16], expected 1, is " << last_msg_->stub[16]; + EXPECT_EQ(last_msg_->stub[17], 39) + << "incorrect value for stub[17], expected 39, is " + << last_msg_->stub[17]; + EXPECT_EQ(last_msg_->stub[18], 1) + << "incorrect value for stub[18], expected 1, is " << last_msg_->stub[18]; + EXPECT_EQ(last_msg_->stub[19], 1) + << "incorrect value for stub[19], expected 1, is " << last_msg_->stub[19]; + EXPECT_EQ(last_msg_->stub[20], 3) + << "incorrect value for stub[20], expected 3, is " << last_msg_->stub[20]; + EXPECT_EQ(last_msg_->stub[21], 39) + << "incorrect value for stub[21], expected 39, is " + << last_msg_->stub[21]; + EXPECT_EQ(last_msg_->stub[22], 1) + << "incorrect value for stub[22], expected 1, is " << last_msg_->stub[22]; + EXPECT_EQ(last_msg_->stub[23], 39) + << "incorrect value for stub[23], expected 39, is " + << last_msg_->stub[23]; + EXPECT_EQ(last_msg_->stub[24], 1) + << "incorrect value for stub[24], expected 1, is " << last_msg_->stub[24]; + EXPECT_EQ(last_msg_->stub[25], 1) + << "incorrect value for stub[25], expected 1, is " << last_msg_->stub[25]; + EXPECT_EQ(last_msg_->stub[26], 1) + << "incorrect value for stub[26], expected 1, is " << last_msg_->stub[26]; + EXPECT_EQ(last_msg_->stub[27], 39) + << "incorrect value for stub[27], expected 39, is " + << last_msg_->stub[27]; + EXPECT_EQ(last_msg_->stub[28], 1) + << "incorrect value for stub[28], expected 1, is " << last_msg_->stub[28]; + EXPECT_EQ(last_msg_->stub[29], 39) + << "incorrect value for stub[29], expected 39, is " + << last_msg_->stub[29]; + EXPECT_EQ(last_msg_->stub[30], 1) + << "incorrect value for stub[30], expected 1, is " << last_msg_->stub[30]; +} diff --git a/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds.cc b/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds.cc new file mode 100644 index 0000000000..00b96c44a9 --- /dev/null +++ b/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds.cc @@ -0,0 +1,430 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrectionBounds.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +class Test_legacy_auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::PayloadHandler { + public: + Test_legacy_auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::PayloadHandler(this), + last_msg_storage_(), + last_msg_(reinterpret_cast( + last_msg_storage_)), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, uint8_t message_length, + const msg_ssr_gridded_correction_bounds_t &msg) override { + memcpy(last_msg_storage_, &msg, message_length); + last_msg_len_ = message_length; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + uint8_t last_msg_storage_[SBP_MAX_PAYLOAD_LEN]; + msg_ssr_gridded_correction_bounds_t *last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_legacy_auto_check_sbp_ssr_MsgSsrGriddedCorrectionBounds0, Test) { + uint8_t encoded_frame[] = { + 85, 254, 5, 66, 0, 43, 180, 0, 0, 0, 3, 0, 1, + 1, 10, 0, 15, 1, 0, 10, 0, 39, 232, 3, 244, 1, + 100, 200, 150, 100, 2, 5, 10, 16, 0, 17, 18, 19, 20, + 21, 6, 10, 22, 0, 23, 24, 25, 26, 27, 112, 145, + }; + + uint8_t test_msg_storage[SBP_MAX_PAYLOAD_LEN]{}; + uint8_t test_msg_len = 0; + msg_ssr_gridded_correction_bounds_t *test_msg = + (msg_ssr_gridded_correction_bounds_t *)test_msg_storage; + test_msg_len = (uint8_t)sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[7] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[8] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[9] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[10] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[11] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[12] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[13] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[14] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[15] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[16] = 232; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[17] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[18] = 244; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[19] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[20] = 100; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[21] = 200; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[22] = 150; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[23] = 100; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[24] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[25] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[26] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[27] = 16; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[28] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[29] = 17; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[30] = 18; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[31] = 19; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[32] = 20; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[33] = 21; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[34] = 6; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[35] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[36] = 22; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[37] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[38] = 23; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[39] = 24; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[40] = 25; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[41] = 26; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[42] = 27; + + EXPECT_EQ(send_message(1534, 66, test_msg_len, test_msg_storage), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_len_, test_msg_len); + EXPECT_EQ(last_msg_->stub[0], 180) + << "incorrect value for stub[0], expected 180, is " << last_msg_->stub[0]; + EXPECT_EQ(last_msg_->stub[1], 0) + << "incorrect value for stub[1], expected 0, is " << last_msg_->stub[1]; + EXPECT_EQ(last_msg_->stub[2], 0) + << "incorrect value for stub[2], expected 0, is " << last_msg_->stub[2]; + EXPECT_EQ(last_msg_->stub[3], 0) + << "incorrect value for stub[3], expected 0, is " << last_msg_->stub[3]; + EXPECT_EQ(last_msg_->stub[4], 3) + << "incorrect value for stub[4], expected 3, is " << last_msg_->stub[4]; + EXPECT_EQ(last_msg_->stub[5], 0) + << "incorrect value for stub[5], expected 0, is " << last_msg_->stub[5]; + EXPECT_EQ(last_msg_->stub[6], 1) + << "incorrect value for stub[6], expected 1, is " << last_msg_->stub[6]; + EXPECT_EQ(last_msg_->stub[7], 1) + << "incorrect value for stub[7], expected 1, is " << last_msg_->stub[7]; + EXPECT_EQ(last_msg_->stub[8], 10) + << "incorrect value for stub[8], expected 10, is " << last_msg_->stub[8]; + EXPECT_EQ(last_msg_->stub[9], 0) + << "incorrect value for stub[9], expected 0, is " << last_msg_->stub[9]; + EXPECT_EQ(last_msg_->stub[10], 15) + << "incorrect value for stub[10], expected 15, is " + << last_msg_->stub[10]; + EXPECT_EQ(last_msg_->stub[11], 1) + << "incorrect value for stub[11], expected 1, is " << last_msg_->stub[11]; + EXPECT_EQ(last_msg_->stub[12], 0) + << "incorrect value for stub[12], expected 0, is " << last_msg_->stub[12]; + EXPECT_EQ(last_msg_->stub[13], 10) + << "incorrect value for stub[13], expected 10, is " + << last_msg_->stub[13]; + EXPECT_EQ(last_msg_->stub[14], 0) + << "incorrect value for stub[14], expected 0, is " << last_msg_->stub[14]; + EXPECT_EQ(last_msg_->stub[15], 39) + << "incorrect value for stub[15], expected 39, is " + << last_msg_->stub[15]; + EXPECT_EQ(last_msg_->stub[16], 232) + << "incorrect value for stub[16], expected 232, is " + << last_msg_->stub[16]; + EXPECT_EQ(last_msg_->stub[17], 3) + << "incorrect value for stub[17], expected 3, is " << last_msg_->stub[17]; + EXPECT_EQ(last_msg_->stub[18], 244) + << "incorrect value for stub[18], expected 244, is " + << last_msg_->stub[18]; + EXPECT_EQ(last_msg_->stub[19], 1) + << "incorrect value for stub[19], expected 1, is " << last_msg_->stub[19]; + EXPECT_EQ(last_msg_->stub[20], 100) + << "incorrect value for stub[20], expected 100, is " + << last_msg_->stub[20]; + EXPECT_EQ(last_msg_->stub[21], 200) + << "incorrect value for stub[21], expected 200, is " + << last_msg_->stub[21]; + EXPECT_EQ(last_msg_->stub[22], 150) + << "incorrect value for stub[22], expected 150, is " + << last_msg_->stub[22]; + EXPECT_EQ(last_msg_->stub[23], 100) + << "incorrect value for stub[23], expected 100, is " + << last_msg_->stub[23]; + EXPECT_EQ(last_msg_->stub[24], 2) + << "incorrect value for stub[24], expected 2, is " << last_msg_->stub[24]; + EXPECT_EQ(last_msg_->stub[25], 5) + << "incorrect value for stub[25], expected 5, is " << last_msg_->stub[25]; + EXPECT_EQ(last_msg_->stub[26], 10) + << "incorrect value for stub[26], expected 10, is " + << last_msg_->stub[26]; + EXPECT_EQ(last_msg_->stub[27], 16) + << "incorrect value for stub[27], expected 16, is " + << last_msg_->stub[27]; + EXPECT_EQ(last_msg_->stub[28], 0) + << "incorrect value for stub[28], expected 0, is " << last_msg_->stub[28]; + EXPECT_EQ(last_msg_->stub[29], 17) + << "incorrect value for stub[29], expected 17, is " + << last_msg_->stub[29]; + EXPECT_EQ(last_msg_->stub[30], 18) + << "incorrect value for stub[30], expected 18, is " + << last_msg_->stub[30]; + EXPECT_EQ(last_msg_->stub[31], 19) + << "incorrect value for stub[31], expected 19, is " + << last_msg_->stub[31]; + EXPECT_EQ(last_msg_->stub[32], 20) + << "incorrect value for stub[32], expected 20, is " + << last_msg_->stub[32]; + EXPECT_EQ(last_msg_->stub[33], 21) + << "incorrect value for stub[33], expected 21, is " + << last_msg_->stub[33]; + EXPECT_EQ(last_msg_->stub[34], 6) + << "incorrect value for stub[34], expected 6, is " << last_msg_->stub[34]; + EXPECT_EQ(last_msg_->stub[35], 10) + << "incorrect value for stub[35], expected 10, is " + << last_msg_->stub[35]; + EXPECT_EQ(last_msg_->stub[36], 22) + << "incorrect value for stub[36], expected 22, is " + << last_msg_->stub[36]; + EXPECT_EQ(last_msg_->stub[37], 0) + << "incorrect value for stub[37], expected 0, is " << last_msg_->stub[37]; + EXPECT_EQ(last_msg_->stub[38], 23) + << "incorrect value for stub[38], expected 23, is " + << last_msg_->stub[38]; + EXPECT_EQ(last_msg_->stub[39], 24) + << "incorrect value for stub[39], expected 24, is " + << last_msg_->stub[39]; + EXPECT_EQ(last_msg_->stub[40], 25) + << "incorrect value for stub[40], expected 25, is " + << last_msg_->stub[40]; + EXPECT_EQ(last_msg_->stub[41], 26) + << "incorrect value for stub[41], expected 26, is " + << last_msg_->stub[41]; + EXPECT_EQ(last_msg_->stub[42], 27) + << "incorrect value for stub[42], expected 27, is " + << last_msg_->stub[42]; +} diff --git a/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrOrbitClockBounds.cc b/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrOrbitClockBounds.cc new file mode 100644 index 0000000000..d1ca4fe066 --- /dev/null +++ b/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrOrbitClockBounds.cc @@ -0,0 +1,332 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBounds.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +class Test_legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBounds0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::PayloadHandler { + public: + Test_legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBounds0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::PayloadHandler(this), + last_msg_storage_(), + last_msg_(reinterpret_cast( + last_msg_storage_)), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, uint8_t message_length, + const msg_ssr_orbit_clock_bounds_t &msg) override { + memcpy(last_msg_storage_, &msg, message_length); + last_msg_len_ = message_length; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + uint8_t last_msg_storage_[SBP_MAX_PAYLOAD_LEN]; + msg_ssr_orbit_clock_bounds_t *last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBounds0, Test) { + uint8_t encoded_frame[] = { + 85, 222, 5, 66, 0, 31, 180, 0, 0, 0, 3, 0, 1, + 2, 3, 48, 15, 1, 2, 24, 39, 38, 37, 1, 2, 3, + 39, 1, 3, 39, 38, 37, 1, 2, 3, 39, 1, 21, 85, + }; + + uint8_t test_msg_storage[SBP_MAX_PAYLOAD_LEN]{}; + uint8_t test_msg_len = 0; + msg_ssr_orbit_clock_bounds_t *test_msg = + (msg_ssr_orbit_clock_bounds_t *)test_msg_storage; + test_msg_len = (uint8_t)sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[7] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[8] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[9] = 48; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[10] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[11] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[12] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[13] = 24; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[14] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[15] = 38; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[16] = 37; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[17] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[18] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[19] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[20] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[21] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[22] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[23] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[24] = 38; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[25] = 37; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[26] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[27] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[28] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[29] = 39; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[30] = 1; + + EXPECT_EQ(send_message(1502, 66, test_msg_len, test_msg_storage), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_len_, test_msg_len); + EXPECT_EQ(last_msg_->stub[0], 180) + << "incorrect value for stub[0], expected 180, is " << last_msg_->stub[0]; + EXPECT_EQ(last_msg_->stub[1], 0) + << "incorrect value for stub[1], expected 0, is " << last_msg_->stub[1]; + EXPECT_EQ(last_msg_->stub[2], 0) + << "incorrect value for stub[2], expected 0, is " << last_msg_->stub[2]; + EXPECT_EQ(last_msg_->stub[3], 0) + << "incorrect value for stub[3], expected 0, is " << last_msg_->stub[3]; + EXPECT_EQ(last_msg_->stub[4], 3) + << "incorrect value for stub[4], expected 3, is " << last_msg_->stub[4]; + EXPECT_EQ(last_msg_->stub[5], 0) + << "incorrect value for stub[5], expected 0, is " << last_msg_->stub[5]; + EXPECT_EQ(last_msg_->stub[6], 1) + << "incorrect value for stub[6], expected 1, is " << last_msg_->stub[6]; + EXPECT_EQ(last_msg_->stub[7], 2) + << "incorrect value for stub[7], expected 2, is " << last_msg_->stub[7]; + EXPECT_EQ(last_msg_->stub[8], 3) + << "incorrect value for stub[8], expected 3, is " << last_msg_->stub[8]; + EXPECT_EQ(last_msg_->stub[9], 48) + << "incorrect value for stub[9], expected 48, is " << last_msg_->stub[9]; + EXPECT_EQ(last_msg_->stub[10], 15) + << "incorrect value for stub[10], expected 15, is " + << last_msg_->stub[10]; + EXPECT_EQ(last_msg_->stub[11], 1) + << "incorrect value for stub[11], expected 1, is " << last_msg_->stub[11]; + EXPECT_EQ(last_msg_->stub[12], 2) + << "incorrect value for stub[12], expected 2, is " << last_msg_->stub[12]; + EXPECT_EQ(last_msg_->stub[13], 24) + << "incorrect value for stub[13], expected 24, is " + << last_msg_->stub[13]; + EXPECT_EQ(last_msg_->stub[14], 39) + << "incorrect value for stub[14], expected 39, is " + << last_msg_->stub[14]; + EXPECT_EQ(last_msg_->stub[15], 38) + << "incorrect value for stub[15], expected 38, is " + << last_msg_->stub[15]; + EXPECT_EQ(last_msg_->stub[16], 37) + << "incorrect value for stub[16], expected 37, is " + << last_msg_->stub[16]; + EXPECT_EQ(last_msg_->stub[17], 1) + << "incorrect value for stub[17], expected 1, is " << last_msg_->stub[17]; + EXPECT_EQ(last_msg_->stub[18], 2) + << "incorrect value for stub[18], expected 2, is " << last_msg_->stub[18]; + EXPECT_EQ(last_msg_->stub[19], 3) + << "incorrect value for stub[19], expected 3, is " << last_msg_->stub[19]; + EXPECT_EQ(last_msg_->stub[20], 39) + << "incorrect value for stub[20], expected 39, is " + << last_msg_->stub[20]; + EXPECT_EQ(last_msg_->stub[21], 1) + << "incorrect value for stub[21], expected 1, is " << last_msg_->stub[21]; + EXPECT_EQ(last_msg_->stub[22], 3) + << "incorrect value for stub[22], expected 3, is " << last_msg_->stub[22]; + EXPECT_EQ(last_msg_->stub[23], 39) + << "incorrect value for stub[23], expected 39, is " + << last_msg_->stub[23]; + EXPECT_EQ(last_msg_->stub[24], 38) + << "incorrect value for stub[24], expected 38, is " + << last_msg_->stub[24]; + EXPECT_EQ(last_msg_->stub[25], 37) + << "incorrect value for stub[25], expected 37, is " + << last_msg_->stub[25]; + EXPECT_EQ(last_msg_->stub[26], 1) + << "incorrect value for stub[26], expected 1, is " << last_msg_->stub[26]; + EXPECT_EQ(last_msg_->stub[27], 2) + << "incorrect value for stub[27], expected 2, is " << last_msg_->stub[27]; + EXPECT_EQ(last_msg_->stub[28], 3) + << "incorrect value for stub[28], expected 3, is " << last_msg_->stub[28]; + EXPECT_EQ(last_msg_->stub[29], 39) + << "incorrect value for stub[29], expected 39, is " + << last_msg_->stub[29]; + EXPECT_EQ(last_msg_->stub[30], 1) + << "incorrect value for stub[30], expected 1, is " << last_msg_->stub[30]; +} diff --git a/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation.cc b/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation.cc new file mode 100644 index 0000000000..224b836b9d --- /dev/null +++ b/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation.cc @@ -0,0 +1,313 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBoundsDegradation.yaml +// by generate.py. Do not modify by hand! + +#include +#include +#include +#include +class Test_legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::PayloadHandler { + public: + Test_legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::PayloadHandler(this), + last_msg_storage_(), + last_msg_(reinterpret_cast( + last_msg_storage_)), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg( + uint16_t sender_id, uint8_t message_length, + const msg_ssr_orbit_clock_bounds_degradation_t &msg) override { + memcpy(last_msg_storage_, &msg, message_length); + last_msg_len_ = message_length; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + uint8_t last_msg_storage_[SBP_MAX_PAYLOAD_LEN]; + msg_ssr_orbit_clock_bounds_degradation_t *last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_legacy_auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradation0, + Test) { + uint8_t encoded_frame[] = { + 85, 223, 5, 66, 0, 28, 180, 0, 0, 0, 3, 0, + 1, 2, 3, 48, 15, 1, 10, 0, 0, 0, 0, 0, + 0, 0, 200, 199, 198, 197, 196, 195, 194, 193, 200, 117, + }; + + uint8_t test_msg_storage[SBP_MAX_PAYLOAD_LEN]{}; + uint8_t test_msg_len = 0; + msg_ssr_orbit_clock_bounds_degradation_t *test_msg = + (msg_ssr_orbit_clock_bounds_degradation_t *)test_msg_storage; + test_msg_len = (uint8_t)sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[7] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[8] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[9] = 48; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[10] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[11] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[12] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[13] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[14] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[15] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[16] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[17] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[18] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[19] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[20] = 200; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[21] = 199; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[22] = 198; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[23] = 197; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[24] = 196; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[25] = 195; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[26] = 194; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[27] = 193; + + EXPECT_EQ(send_message(1503, 66, test_msg_len, test_msg_storage), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_len_, test_msg_len); + EXPECT_EQ(last_msg_->stub[0], 180) + << "incorrect value for stub[0], expected 180, is " << last_msg_->stub[0]; + EXPECT_EQ(last_msg_->stub[1], 0) + << "incorrect value for stub[1], expected 0, is " << last_msg_->stub[1]; + EXPECT_EQ(last_msg_->stub[2], 0) + << "incorrect value for stub[2], expected 0, is " << last_msg_->stub[2]; + EXPECT_EQ(last_msg_->stub[3], 0) + << "incorrect value for stub[3], expected 0, is " << last_msg_->stub[3]; + EXPECT_EQ(last_msg_->stub[4], 3) + << "incorrect value for stub[4], expected 3, is " << last_msg_->stub[4]; + EXPECT_EQ(last_msg_->stub[5], 0) + << "incorrect value for stub[5], expected 0, is " << last_msg_->stub[5]; + EXPECT_EQ(last_msg_->stub[6], 1) + << "incorrect value for stub[6], expected 1, is " << last_msg_->stub[6]; + EXPECT_EQ(last_msg_->stub[7], 2) + << "incorrect value for stub[7], expected 2, is " << last_msg_->stub[7]; + EXPECT_EQ(last_msg_->stub[8], 3) + << "incorrect value for stub[8], expected 3, is " << last_msg_->stub[8]; + EXPECT_EQ(last_msg_->stub[9], 48) + << "incorrect value for stub[9], expected 48, is " << last_msg_->stub[9]; + EXPECT_EQ(last_msg_->stub[10], 15) + << "incorrect value for stub[10], expected 15, is " + << last_msg_->stub[10]; + EXPECT_EQ(last_msg_->stub[11], 1) + << "incorrect value for stub[11], expected 1, is " << last_msg_->stub[11]; + EXPECT_EQ(last_msg_->stub[12], 10) + << "incorrect value for stub[12], expected 10, is " + << last_msg_->stub[12]; + EXPECT_EQ(last_msg_->stub[13], 0) + << "incorrect value for stub[13], expected 0, is " << last_msg_->stub[13]; + EXPECT_EQ(last_msg_->stub[14], 0) + << "incorrect value for stub[14], expected 0, is " << last_msg_->stub[14]; + EXPECT_EQ(last_msg_->stub[15], 0) + << "incorrect value for stub[15], expected 0, is " << last_msg_->stub[15]; + EXPECT_EQ(last_msg_->stub[16], 0) + << "incorrect value for stub[16], expected 0, is " << last_msg_->stub[16]; + EXPECT_EQ(last_msg_->stub[17], 0) + << "incorrect value for stub[17], expected 0, is " << last_msg_->stub[17]; + EXPECT_EQ(last_msg_->stub[18], 0) + << "incorrect value for stub[18], expected 0, is " << last_msg_->stub[18]; + EXPECT_EQ(last_msg_->stub[19], 0) + << "incorrect value for stub[19], expected 0, is " << last_msg_->stub[19]; + EXPECT_EQ(last_msg_->stub[20], 200) + << "incorrect value for stub[20], expected 200, is " + << last_msg_->stub[20]; + EXPECT_EQ(last_msg_->stub[21], 199) + << "incorrect value for stub[21], expected 199, is " + << last_msg_->stub[21]; + EXPECT_EQ(last_msg_->stub[22], 198) + << "incorrect value for stub[22], expected 198, is " + << last_msg_->stub[22]; + EXPECT_EQ(last_msg_->stub[23], 197) + << "incorrect value for stub[23], expected 197, is " + << last_msg_->stub[23]; + EXPECT_EQ(last_msg_->stub[24], 196) + << "incorrect value for stub[24], expected 196, is " + << last_msg_->stub[24]; + EXPECT_EQ(last_msg_->stub[25], 195) + << "incorrect value for stub[25], expected 195, is " + << last_msg_->stub[25]; + EXPECT_EQ(last_msg_->stub[26], 194) + << "incorrect value for stub[26], expected 194, is " + << last_msg_->stub[26]; + EXPECT_EQ(last_msg_->stub[27], 193) + << "incorrect value for stub[27], expected 193, is " + << last_msg_->stub[27]; +} diff --git a/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrStecCorrection.cc b/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrStecCorrection.cc new file mode 100644 index 0000000000..198ee2e32a --- /dev/null +++ b/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrStecCorrection.cc @@ -0,0 +1,383 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrStecCorrection.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +class Test_legacy_auto_check_sbp_ssr_MsgSsrStecCorrection0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::PayloadHandler { + public: + Test_legacy_auto_check_sbp_ssr_MsgSsrStecCorrection0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::PayloadHandler(this), + last_msg_storage_(), + last_msg_( + reinterpret_cast(last_msg_storage_)), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, uint8_t message_length, + const msg_ssr_stec_correction_t &msg) override { + memcpy(last_msg_storage_, &msg, message_length); + last_msg_len_ = message_length; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + uint8_t last_msg_storage_[SBP_MAX_PAYLOAD_LEN]; + msg_ssr_stec_correction_t *last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_legacy_auto_check_sbp_ssr_MsgSsrStecCorrection0, Test) { + uint8_t encoded_frame[] = { + 85, 253, 5, 66, 0, 38, 180, 0, 0, 0, 3, 0, 1, 1, 10, 0, + 15, 1, 0, 10, 0, 2, 1, 1, 1, 63, 0, 62, 0, 61, 0, 60, + 0, 31, 15, 5, 63, 0, 64, 0, 65, 0, 66, 0, 119, 50, + }; + + uint8_t test_msg_storage[SBP_MAX_PAYLOAD_LEN]{}; + uint8_t test_msg_len = 0; + msg_ssr_stec_correction_t *test_msg = + (msg_ssr_stec_correction_t *)test_msg_storage; + test_msg_len = (uint8_t)sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[0] = 180; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[2] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[4] = 3; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[6] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[7] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[8] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[9] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[10] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[11] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[12] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[13] = 10; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[14] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[15] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[16] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[17] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[18] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[19] = 63; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[20] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[21] = 62; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[22] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[23] = 61; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[24] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[25] = 60; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[26] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[27] = 31; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[28] = 15; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[29] = 5; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[30] = 63; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[31] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[32] = 64; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[33] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[34] = 65; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[35] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[36] = 66; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[37] = 0; + + EXPECT_EQ(send_message(1533, 66, test_msg_len, test_msg_storage), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_len_, test_msg_len); + EXPECT_EQ(last_msg_->stub[0], 180) + << "incorrect value for stub[0], expected 180, is " << last_msg_->stub[0]; + EXPECT_EQ(last_msg_->stub[1], 0) + << "incorrect value for stub[1], expected 0, is " << last_msg_->stub[1]; + EXPECT_EQ(last_msg_->stub[2], 0) + << "incorrect value for stub[2], expected 0, is " << last_msg_->stub[2]; + EXPECT_EQ(last_msg_->stub[3], 0) + << "incorrect value for stub[3], expected 0, is " << last_msg_->stub[3]; + EXPECT_EQ(last_msg_->stub[4], 3) + << "incorrect value for stub[4], expected 3, is " << last_msg_->stub[4]; + EXPECT_EQ(last_msg_->stub[5], 0) + << "incorrect value for stub[5], expected 0, is " << last_msg_->stub[5]; + EXPECT_EQ(last_msg_->stub[6], 1) + << "incorrect value for stub[6], expected 1, is " << last_msg_->stub[6]; + EXPECT_EQ(last_msg_->stub[7], 1) + << "incorrect value for stub[7], expected 1, is " << last_msg_->stub[7]; + EXPECT_EQ(last_msg_->stub[8], 10) + << "incorrect value for stub[8], expected 10, is " << last_msg_->stub[8]; + EXPECT_EQ(last_msg_->stub[9], 0) + << "incorrect value for stub[9], expected 0, is " << last_msg_->stub[9]; + EXPECT_EQ(last_msg_->stub[10], 15) + << "incorrect value for stub[10], expected 15, is " + << last_msg_->stub[10]; + EXPECT_EQ(last_msg_->stub[11], 1) + << "incorrect value for stub[11], expected 1, is " << last_msg_->stub[11]; + EXPECT_EQ(last_msg_->stub[12], 0) + << "incorrect value for stub[12], expected 0, is " << last_msg_->stub[12]; + EXPECT_EQ(last_msg_->stub[13], 10) + << "incorrect value for stub[13], expected 10, is " + << last_msg_->stub[13]; + EXPECT_EQ(last_msg_->stub[14], 0) + << "incorrect value for stub[14], expected 0, is " << last_msg_->stub[14]; + EXPECT_EQ(last_msg_->stub[15], 2) + << "incorrect value for stub[15], expected 2, is " << last_msg_->stub[15]; + EXPECT_EQ(last_msg_->stub[16], 1) + << "incorrect value for stub[16], expected 1, is " << last_msg_->stub[16]; + EXPECT_EQ(last_msg_->stub[17], 1) + << "incorrect value for stub[17], expected 1, is " << last_msg_->stub[17]; + EXPECT_EQ(last_msg_->stub[18], 1) + << "incorrect value for stub[18], expected 1, is " << last_msg_->stub[18]; + EXPECT_EQ(last_msg_->stub[19], 63) + << "incorrect value for stub[19], expected 63, is " + << last_msg_->stub[19]; + EXPECT_EQ(last_msg_->stub[20], 0) + << "incorrect value for stub[20], expected 0, is " << last_msg_->stub[20]; + EXPECT_EQ(last_msg_->stub[21], 62) + << "incorrect value for stub[21], expected 62, is " + << last_msg_->stub[21]; + EXPECT_EQ(last_msg_->stub[22], 0) + << "incorrect value for stub[22], expected 0, is " << last_msg_->stub[22]; + EXPECT_EQ(last_msg_->stub[23], 61) + << "incorrect value for stub[23], expected 61, is " + << last_msg_->stub[23]; + EXPECT_EQ(last_msg_->stub[24], 0) + << "incorrect value for stub[24], expected 0, is " << last_msg_->stub[24]; + EXPECT_EQ(last_msg_->stub[25], 60) + << "incorrect value for stub[25], expected 60, is " + << last_msg_->stub[25]; + EXPECT_EQ(last_msg_->stub[26], 0) + << "incorrect value for stub[26], expected 0, is " << last_msg_->stub[26]; + EXPECT_EQ(last_msg_->stub[27], 31) + << "incorrect value for stub[27], expected 31, is " + << last_msg_->stub[27]; + EXPECT_EQ(last_msg_->stub[28], 15) + << "incorrect value for stub[28], expected 15, is " + << last_msg_->stub[28]; + EXPECT_EQ(last_msg_->stub[29], 5) + << "incorrect value for stub[29], expected 5, is " << last_msg_->stub[29]; + EXPECT_EQ(last_msg_->stub[30], 63) + << "incorrect value for stub[30], expected 63, is " + << last_msg_->stub[30]; + EXPECT_EQ(last_msg_->stub[31], 0) + << "incorrect value for stub[31], expected 0, is " << last_msg_->stub[31]; + EXPECT_EQ(last_msg_->stub[32], 64) + << "incorrect value for stub[32], expected 64, is " + << last_msg_->stub[32]; + EXPECT_EQ(last_msg_->stub[33], 0) + << "incorrect value for stub[33], expected 0, is " << last_msg_->stub[33]; + EXPECT_EQ(last_msg_->stub[34], 65) + << "incorrect value for stub[34], expected 65, is " + << last_msg_->stub[34]; + EXPECT_EQ(last_msg_->stub[35], 0) + << "incorrect value for stub[35], expected 0, is " << last_msg_->stub[35]; + EXPECT_EQ(last_msg_->stub[36], 66) + << "incorrect value for stub[36], expected 66, is " + << last_msg_->stub[36]; + EXPECT_EQ(last_msg_->stub[37], 0) + << "incorrect value for stub[37], expected 0, is " << last_msg_->stub[37]; +} diff --git a/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrTileDefinition.cc b/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrTileDefinition.cc new file mode 100644 index 0000000000..6c1c210a24 --- /dev/null +++ b/c/test/legacy/cpp/auto_check_sbp_ssr_MsgSsrTileDefinition.cc @@ -0,0 +1,286 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrTileDefinition.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +class Test_legacy_auto_check_sbp_ssr_MsgSsrTileDefinition0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::PayloadHandler { + public: + Test_legacy_auto_check_sbp_ssr_MsgSsrTileDefinition0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::PayloadHandler(this), + last_msg_storage_(), + last_msg_( + reinterpret_cast(last_msg_storage_)), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, uint8_t message_length, + const msg_ssr_tile_definition_t &msg) override { + memcpy(last_msg_storage_, &msg, message_length); + last_msg_len_ = message_length; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + uint8_t last_msg_storage_[SBP_MAX_PAYLOAD_LEN]; + msg_ssr_tile_definition_t *last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_legacy_auto_check_sbp_ssr_MsgSsrTileDefinition0, Test) { + uint8_t encoded_frame[] = { + 85, 247, 5, 66, 0, 25, 31, 0, 1, 0, 2, 0, 4, 0, 8, 0, 16, + 0, 32, 0, 64, 0, 128, 210, 2, 150, 73, 0, 0, 0, 0, 214, 71, + }; + + uint8_t test_msg_storage[SBP_MAX_PAYLOAD_LEN]{}; + uint8_t test_msg_len = 0; + msg_ssr_tile_definition_t *test_msg = + (msg_ssr_tile_definition_t *)test_msg_storage; + test_msg_len = (uint8_t)sizeof(*test_msg); + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[0] = 31; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[1] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[2] = 1; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[3] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[4] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[5] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[6] = 4; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[7] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[8] = 8; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[9] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[10] = 16; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[11] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[12] = 32; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[13] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[14] = 64; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[15] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[16] = 128; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[17] = 210; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[18] = 2; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[19] = 150; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[20] = 73; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[21] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[22] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[23] = 0; + if (sizeof(test_msg->stub) == 0) { + // Cope with variable length arrays + test_msg_len = (uint8_t)(test_msg_len + sizeof(test_msg->stub[0])); + } + test_msg->stub[24] = 0; + + EXPECT_EQ(send_message(1527, 66, test_msg_len, test_msg_storage), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_len_, test_msg_len); + EXPECT_EQ(last_msg_->stub[0], 31) + << "incorrect value for stub[0], expected 31, is " << last_msg_->stub[0]; + EXPECT_EQ(last_msg_->stub[1], 0) + << "incorrect value for stub[1], expected 0, is " << last_msg_->stub[1]; + EXPECT_EQ(last_msg_->stub[2], 1) + << "incorrect value for stub[2], expected 1, is " << last_msg_->stub[2]; + EXPECT_EQ(last_msg_->stub[3], 0) + << "incorrect value for stub[3], expected 0, is " << last_msg_->stub[3]; + EXPECT_EQ(last_msg_->stub[4], 2) + << "incorrect value for stub[4], expected 2, is " << last_msg_->stub[4]; + EXPECT_EQ(last_msg_->stub[5], 0) + << "incorrect value for stub[5], expected 0, is " << last_msg_->stub[5]; + EXPECT_EQ(last_msg_->stub[6], 4) + << "incorrect value for stub[6], expected 4, is " << last_msg_->stub[6]; + EXPECT_EQ(last_msg_->stub[7], 0) + << "incorrect value for stub[7], expected 0, is " << last_msg_->stub[7]; + EXPECT_EQ(last_msg_->stub[8], 8) + << "incorrect value for stub[8], expected 8, is " << last_msg_->stub[8]; + EXPECT_EQ(last_msg_->stub[9], 0) + << "incorrect value for stub[9], expected 0, is " << last_msg_->stub[9]; + EXPECT_EQ(last_msg_->stub[10], 16) + << "incorrect value for stub[10], expected 16, is " + << last_msg_->stub[10]; + EXPECT_EQ(last_msg_->stub[11], 0) + << "incorrect value for stub[11], expected 0, is " << last_msg_->stub[11]; + EXPECT_EQ(last_msg_->stub[12], 32) + << "incorrect value for stub[12], expected 32, is " + << last_msg_->stub[12]; + EXPECT_EQ(last_msg_->stub[13], 0) + << "incorrect value for stub[13], expected 0, is " << last_msg_->stub[13]; + EXPECT_EQ(last_msg_->stub[14], 64) + << "incorrect value for stub[14], expected 64, is " + << last_msg_->stub[14]; + EXPECT_EQ(last_msg_->stub[15], 0) + << "incorrect value for stub[15], expected 0, is " << last_msg_->stub[15]; + EXPECT_EQ(last_msg_->stub[16], 128) + << "incorrect value for stub[16], expected 128, is " + << last_msg_->stub[16]; + EXPECT_EQ(last_msg_->stub[17], 210) + << "incorrect value for stub[17], expected 210, is " + << last_msg_->stub[17]; + EXPECT_EQ(last_msg_->stub[18], 2) + << "incorrect value for stub[18], expected 2, is " << last_msg_->stub[18]; + EXPECT_EQ(last_msg_->stub[19], 150) + << "incorrect value for stub[19], expected 150, is " + << last_msg_->stub[19]; + EXPECT_EQ(last_msg_->stub[20], 73) + << "incorrect value for stub[20], expected 73, is " + << last_msg_->stub[20]; + EXPECT_EQ(last_msg_->stub[21], 0) + << "incorrect value for stub[21], expected 0, is " << last_msg_->stub[21]; + EXPECT_EQ(last_msg_->stub[22], 0) + << "incorrect value for stub[22], expected 0, is " << last_msg_->stub[22]; + EXPECT_EQ(last_msg_->stub[23], 0) + << "incorrect value for stub[23], expected 0, is " << last_msg_->stub[23]; + EXPECT_EQ(last_msg_->stub[24], 0) + << "incorrect value for stub[24], expected 0, is " << last_msg_->stub[24]; +} diff --git a/docs/sbp.pdf b/docs/sbp.pdf index 7699c80af44c7fbfc666bd003f54aaa85739fb72..751645fca6fecbdbe631cec5a63e7e56cb77c482 100644 GIT binary patch delta 145424 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 z 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 U_5h;9;1S~EL#L;gQ;|pi4`@yuPXGV_ delta 144287 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

EpWWyBQ)GnC3)>pn#m{jO^f6|~#* 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

D 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≤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∋i+lX3h|)H0Xz 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 diff --git a/haskell/sbp.cabal b/haskell/sbp.cabal index bfcea6cce6..51e5c695db 100644 --- a/haskell/sbp.cabal +++ b/haskell/sbp.cabal @@ -32,6 +32,7 @@ library , SwiftNav.SBP.Flash , SwiftNav.SBP.Gnss , SwiftNav.SBP.Imu + , SwiftNav.SBP.Integrity , SwiftNav.SBP.Linux , SwiftNav.SBP.Logging , SwiftNav.SBP.Mag diff --git a/haskell/src/SwiftNav/SBP.hs b/haskell/src/SwiftNav/SBP.hs index b5de8301f4..818833b7ef 100644 --- a/haskell/src/SwiftNav/SBP.hs +++ b/haskell/src/SwiftNav/SBP.hs @@ -21,6 +21,7 @@ import SwiftNav.SBP.FileIo as Exports import SwiftNav.SBP.Flash as Exports import SwiftNav.SBP.Gnss as Exports import SwiftNav.SBP.Imu as Exports +import SwiftNav.SBP.Integrity as Exports import SwiftNav.SBP.Linux as Exports import SwiftNav.SBP.Logging as Exports import SwiftNav.SBP.Mag as Exports diff --git a/haskell/src/SwiftNav/SBP/Integrity.hs b/haskell/src/SwiftNav/SBP/Integrity.hs new file mode 100644 index 0000000000..98dea0cfe8 --- /dev/null +++ b/haskell/src/SwiftNav/SBP/Integrity.hs @@ -0,0 +1,151 @@ +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE RecordWildCards #-} + +-- | +-- Module: SwiftNav.SBP.Integrity +-- Copyright: Copyright (C) 2015-2021 Swift Navigation, Inc. +-- License: MIT +-- Contact: https://support.swiftnav.com +-- Stability: experimental +-- Portability: portable +-- +-- \< Integrity flag messages \> + +module SwiftNav.SBP.Integrity + ( module SwiftNav.SBP.Integrity + ) where + +import BasicPrelude +import Control.Lens +import Control.Monad.Loops +import Data.Binary +import Data.Binary.Get +import Data.Binary.IEEE754 +import Data.Binary.Put +import Data.ByteString.Lazy hiding (ByteString) +import Data.Int +import Data.Word +import SwiftNav.SBP.TH +import SwiftNav.SBP.Types +import SwiftNav.SBP.Gnss + +{-# ANN module ("HLint: ignore Use camelCase"::String) #-} +{-# ANN module ("HLint: ignore Redundant do"::String) #-} +{-# ANN module ("HLint: ignore Use newtype instead of data"::String) #-} + + +msgSsrFlagHighLevel :: Word16 +msgSsrFlagHighLevel = 0x0BB9 + +data MsgSsrFlagHighLevel = MsgSsrFlagHighLevel + { _msgSsrFlagHighLevel_stub :: ![Word8] + } deriving ( Show, Read, Eq ) + +instance Binary MsgSsrFlagHighLevel where + get = do + _msgSsrFlagHighLevel_stub <- whileM (not <$> isEmpty) getWord8 + pure MsgSsrFlagHighLevel {..} + + put MsgSsrFlagHighLevel {..} = do + mapM_ putWord8 _msgSsrFlagHighLevel_stub + +$(makeSBP 'msgSsrFlagHighLevel ''MsgSsrFlagHighLevel) +$(makeJSON "_msgSsrFlagHighLevel_" ''MsgSsrFlagHighLevel) +$(makeLenses ''MsgSsrFlagHighLevel) + +msgSsrFlagSatellites :: Word16 +msgSsrFlagSatellites = 0x0BBD + +data MsgSsrFlagSatellites = MsgSsrFlagSatellites + { _msgSsrFlagSatellites_stub :: ![Word8] + } deriving ( Show, Read, Eq ) + +instance Binary MsgSsrFlagSatellites where + get = do + _msgSsrFlagSatellites_stub <- whileM (not <$> isEmpty) getWord8 + pure MsgSsrFlagSatellites {..} + + put MsgSsrFlagSatellites {..} = do + mapM_ putWord8 _msgSsrFlagSatellites_stub + +$(makeSBP 'msgSsrFlagSatellites ''MsgSsrFlagSatellites) +$(makeJSON "_msgSsrFlagSatellites_" ''MsgSsrFlagSatellites) +$(makeLenses ''MsgSsrFlagSatellites) + +msgSsrFlagTropoGridPoints :: Word16 +msgSsrFlagTropoGridPoints = 0x0BC3 + +data MsgSsrFlagTropoGridPoints = MsgSsrFlagTropoGridPoints + { _msgSsrFlagTropoGridPoints_stub :: ![Word8] + } deriving ( Show, Read, Eq ) + +instance Binary MsgSsrFlagTropoGridPoints where + get = do + _msgSsrFlagTropoGridPoints_stub <- whileM (not <$> isEmpty) getWord8 + pure MsgSsrFlagTropoGridPoints {..} + + put MsgSsrFlagTropoGridPoints {..} = do + mapM_ putWord8 _msgSsrFlagTropoGridPoints_stub + +$(makeSBP 'msgSsrFlagTropoGridPoints ''MsgSsrFlagTropoGridPoints) +$(makeJSON "_msgSsrFlagTropoGridPoints_" ''MsgSsrFlagTropoGridPoints) +$(makeLenses ''MsgSsrFlagTropoGridPoints) + +msgSsrFlagIonoGridPoints :: Word16 +msgSsrFlagIonoGridPoints = 0x0BC7 + +data MsgSsrFlagIonoGridPoints = MsgSsrFlagIonoGridPoints + { _msgSsrFlagIonoGridPoints_stub :: ![Word8] + } deriving ( Show, Read, Eq ) + +instance Binary MsgSsrFlagIonoGridPoints where + get = do + _msgSsrFlagIonoGridPoints_stub <- whileM (not <$> isEmpty) getWord8 + pure MsgSsrFlagIonoGridPoints {..} + + put MsgSsrFlagIonoGridPoints {..} = do + mapM_ putWord8 _msgSsrFlagIonoGridPoints_stub + +$(makeSBP 'msgSsrFlagIonoGridPoints ''MsgSsrFlagIonoGridPoints) +$(makeJSON "_msgSsrFlagIonoGridPoints_" ''MsgSsrFlagIonoGridPoints) +$(makeLenses ''MsgSsrFlagIonoGridPoints) + +msgSsrFlagIonoTileSatLos :: Word16 +msgSsrFlagIonoTileSatLos = 0x0BCD + +data MsgSsrFlagIonoTileSatLos = MsgSsrFlagIonoTileSatLos + { _msgSsrFlagIonoTileSatLos_stub :: ![Word8] + } deriving ( Show, Read, Eq ) + +instance Binary MsgSsrFlagIonoTileSatLos where + get = do + _msgSsrFlagIonoTileSatLos_stub <- whileM (not <$> isEmpty) getWord8 + pure MsgSsrFlagIonoTileSatLos {..} + + put MsgSsrFlagIonoTileSatLos {..} = do + mapM_ putWord8 _msgSsrFlagIonoTileSatLos_stub + +$(makeSBP 'msgSsrFlagIonoTileSatLos ''MsgSsrFlagIonoTileSatLos) +$(makeJSON "_msgSsrFlagIonoTileSatLos_" ''MsgSsrFlagIonoTileSatLos) +$(makeLenses ''MsgSsrFlagIonoTileSatLos) + +msgSsrFlagIonoGridPointSatLos :: Word16 +msgSsrFlagIonoGridPointSatLos = 0x0BD1 + +data MsgSsrFlagIonoGridPointSatLos = MsgSsrFlagIonoGridPointSatLos + { _msgSsrFlagIonoGridPointSatLos_stub :: ![Word8] + } deriving ( Show, Read, Eq ) + +instance Binary MsgSsrFlagIonoGridPointSatLos where + get = do + _msgSsrFlagIonoGridPointSatLos_stub <- whileM (not <$> isEmpty) getWord8 + pure MsgSsrFlagIonoGridPointSatLos {..} + + put MsgSsrFlagIonoGridPointSatLos {..} = do + mapM_ putWord8 _msgSsrFlagIonoGridPointSatLos_stub + +$(makeSBP 'msgSsrFlagIonoGridPointSatLos ''MsgSsrFlagIonoGridPointSatLos) +$(makeJSON "_msgSsrFlagIonoGridPointSatLos_" ''MsgSsrFlagIonoGridPointSatLos) +$(makeLenses ''MsgSsrFlagIonoGridPointSatLos) diff --git a/haskell/src/SwiftNav/SBP/Msg.hs b/haskell/src/SwiftNav/SBP/Msg.hs index 3e3afdd619..07a9bb3dd1 100644 --- a/haskell/src/SwiftNav/SBP/Msg.hs +++ b/haskell/src/SwiftNav/SBP/Msg.hs @@ -31,6 +31,7 @@ import SwiftNav.SBP.FileIo import SwiftNav.SBP.Flash import SwiftNav.SBP.Gnss import SwiftNav.SBP.Imu +import SwiftNav.SBP.Integrity import SwiftNav.SBP.Linux import SwiftNav.SBP.Logging import SwiftNav.SBP.Mag @@ -131,6 +132,7 @@ data SBPMsg = | SBPMsgGloBiases MsgGloBiases Msg | SBPMsgGnssCapb MsgGnssCapb Msg | SBPMsgGnssTimeOffset MsgGnssTimeOffset Msg + | SBPMsgGpsLeapSecond MsgGpsLeapSecond Msg | SBPMsgGpsTime MsgGpsTime Msg | SBPMsgGpsTimeDepA MsgGpsTimeDepA Msg | SBPMsgGpsTimeGnss MsgGpsTimeGnss Msg @@ -146,6 +148,7 @@ data SBPMsg = | SBPMsgInsStatus MsgInsStatus Msg | SBPMsgInsUpdates MsgInsUpdates Msg | SBPMsgIono MsgIono Msg + | SBPMsgItrf MsgItrf Msg | SBPMsgLinuxCpuState MsgLinuxCpuState Msg | SBPMsgLinuxCpuStateDepA MsgLinuxCpuStateDepA Msg | SBPMsgLinuxMemState MsgLinuxMemState Msg @@ -213,17 +216,29 @@ data SBPMsg = | SBPMsgSpecan MsgSpecan Msg | SBPMsgSpecanDep MsgSpecanDep Msg | SBPMsgSsrCodeBiases MsgSsrCodeBiases Msg + | SBPMsgSsrCodePhaseBiasesBounds MsgSsrCodePhaseBiasesBounds Msg + | SBPMsgSsrFlagHighLevel MsgSsrFlagHighLevel Msg + | SBPMsgSsrFlagIonoGridPointSatLos MsgSsrFlagIonoGridPointSatLos Msg + | SBPMsgSsrFlagIonoGridPoints MsgSsrFlagIonoGridPoints Msg + | SBPMsgSsrFlagIonoTileSatLos MsgSsrFlagIonoTileSatLos Msg + | SBPMsgSsrFlagSatellites MsgSsrFlagSatellites Msg + | SBPMsgSsrFlagTropoGridPoints MsgSsrFlagTropoGridPoints Msg | SBPMsgSsrGridDefinitionDepA MsgSsrGridDefinitionDepA Msg | SBPMsgSsrGriddedCorrection MsgSsrGriddedCorrection Msg + | SBPMsgSsrGriddedCorrectionBounds MsgSsrGriddedCorrectionBounds Msg | SBPMsgSsrGriddedCorrectionDepA MsgSsrGriddedCorrectionDepA Msg | SBPMsgSsrGriddedCorrectionNoStdDepA MsgSsrGriddedCorrectionNoStdDepA Msg | SBPMsgSsrOrbitClock MsgSsrOrbitClock Msg + | SBPMsgSsrOrbitClockBounds MsgSsrOrbitClockBounds Msg + | SBPMsgSsrOrbitClockBoundsDegradation MsgSsrOrbitClockBoundsDegradation Msg | SBPMsgSsrOrbitClockDepA MsgSsrOrbitClockDepA Msg | SBPMsgSsrPhaseBiases MsgSsrPhaseBiases Msg | SBPMsgSsrSatelliteApc MsgSsrSatelliteApc Msg | SBPMsgSsrStecCorrection MsgSsrStecCorrection Msg + | SBPMsgSsrStecCorrectionDep MsgSsrStecCorrectionDep Msg | SBPMsgSsrStecCorrectionDepA MsgSsrStecCorrectionDepA Msg | SBPMsgSsrTileDefinition MsgSsrTileDefinition Msg + | SBPMsgSsrTileDefinitionDep MsgSsrTileDefinitionDep Msg | SBPMsgStartup MsgStartup Msg | SBPMsgStatusJournal MsgStatusJournal Msg | SBPMsgStatusReport MsgStatusReport Msg @@ -349,6 +364,7 @@ instance Binary SBPMsg where | _msgSBPType == msgGloBiases = SBPMsgGloBiases (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgGnssCapb = SBPMsgGnssCapb (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgGnssTimeOffset = SBPMsgGnssTimeOffset (decode (fromStrict (unBytes _msgSBPPayload))) m + | _msgSBPType == msgGpsLeapSecond = SBPMsgGpsLeapSecond (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgGpsTime = SBPMsgGpsTime (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgGpsTimeDepA = SBPMsgGpsTimeDepA (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgGpsTimeGnss = SBPMsgGpsTimeGnss (decode (fromStrict (unBytes _msgSBPPayload))) m @@ -364,6 +380,7 @@ instance Binary SBPMsg where | _msgSBPType == msgInsStatus = SBPMsgInsStatus (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgInsUpdates = SBPMsgInsUpdates (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgIono = SBPMsgIono (decode (fromStrict (unBytes _msgSBPPayload))) m + | _msgSBPType == msgItrf = SBPMsgItrf (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgLinuxCpuState = SBPMsgLinuxCpuState (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgLinuxCpuStateDepA = SBPMsgLinuxCpuStateDepA (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgLinuxMemState = SBPMsgLinuxMemState (decode (fromStrict (unBytes _msgSBPPayload))) m @@ -431,17 +448,29 @@ instance Binary SBPMsg where | _msgSBPType == msgSpecan = SBPMsgSpecan (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSpecanDep = SBPMsgSpecanDep (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrCodeBiases = SBPMsgSsrCodeBiases (decode (fromStrict (unBytes _msgSBPPayload))) m + | _msgSBPType == msgSsrCodePhaseBiasesBounds = SBPMsgSsrCodePhaseBiasesBounds (decode (fromStrict (unBytes _msgSBPPayload))) m + | _msgSBPType == msgSsrFlagHighLevel = SBPMsgSsrFlagHighLevel (decode (fromStrict (unBytes _msgSBPPayload))) m + | _msgSBPType == msgSsrFlagIonoGridPointSatLos = SBPMsgSsrFlagIonoGridPointSatLos (decode (fromStrict (unBytes _msgSBPPayload))) m + | _msgSBPType == msgSsrFlagIonoGridPoints = SBPMsgSsrFlagIonoGridPoints (decode (fromStrict (unBytes _msgSBPPayload))) m + | _msgSBPType == msgSsrFlagIonoTileSatLos = SBPMsgSsrFlagIonoTileSatLos (decode (fromStrict (unBytes _msgSBPPayload))) m + | _msgSBPType == msgSsrFlagSatellites = SBPMsgSsrFlagSatellites (decode (fromStrict (unBytes _msgSBPPayload))) m + | _msgSBPType == msgSsrFlagTropoGridPoints = SBPMsgSsrFlagTropoGridPoints (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrGridDefinitionDepA = SBPMsgSsrGridDefinitionDepA (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrGriddedCorrection = SBPMsgSsrGriddedCorrection (decode (fromStrict (unBytes _msgSBPPayload))) m + | _msgSBPType == msgSsrGriddedCorrectionBounds = SBPMsgSsrGriddedCorrectionBounds (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrGriddedCorrectionDepA = SBPMsgSsrGriddedCorrectionDepA (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrGriddedCorrectionNoStdDepA = SBPMsgSsrGriddedCorrectionNoStdDepA (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrOrbitClock = SBPMsgSsrOrbitClock (decode (fromStrict (unBytes _msgSBPPayload))) m + | _msgSBPType == msgSsrOrbitClockBounds = SBPMsgSsrOrbitClockBounds (decode (fromStrict (unBytes _msgSBPPayload))) m + | _msgSBPType == msgSsrOrbitClockBoundsDegradation = SBPMsgSsrOrbitClockBoundsDegradation (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrOrbitClockDepA = SBPMsgSsrOrbitClockDepA (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrPhaseBiases = SBPMsgSsrPhaseBiases (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrSatelliteApc = SBPMsgSsrSatelliteApc (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrStecCorrection = SBPMsgSsrStecCorrection (decode (fromStrict (unBytes _msgSBPPayload))) m + | _msgSBPType == msgSsrStecCorrectionDep = SBPMsgSsrStecCorrectionDep (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrStecCorrectionDepA = SBPMsgSsrStecCorrectionDepA (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrTileDefinition = SBPMsgSsrTileDefinition (decode (fromStrict (unBytes _msgSBPPayload))) m + | _msgSBPType == msgSsrTileDefinitionDep = SBPMsgSsrTileDefinitionDep (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgStartup = SBPMsgStartup (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgStatusJournal = SBPMsgStatusJournal (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgStatusReport = SBPMsgStatusReport (decode (fromStrict (unBytes _msgSBPPayload))) m @@ -559,6 +588,7 @@ instance Binary SBPMsg where encoder (SBPMsgGloBiases _ m) = put m encoder (SBPMsgGnssCapb _ m) = put m encoder (SBPMsgGnssTimeOffset _ m) = put m + encoder (SBPMsgGpsLeapSecond _ m) = put m encoder (SBPMsgGpsTime _ m) = put m encoder (SBPMsgGpsTimeDepA _ m) = put m encoder (SBPMsgGpsTimeGnss _ m) = put m @@ -574,6 +604,7 @@ instance Binary SBPMsg where encoder (SBPMsgInsStatus _ m) = put m encoder (SBPMsgInsUpdates _ m) = put m encoder (SBPMsgIono _ m) = put m + encoder (SBPMsgItrf _ m) = put m encoder (SBPMsgLinuxCpuState _ m) = put m encoder (SBPMsgLinuxCpuStateDepA _ m) = put m encoder (SBPMsgLinuxMemState _ m) = put m @@ -641,17 +672,29 @@ instance Binary SBPMsg where encoder (SBPMsgSpecan _ m) = put m encoder (SBPMsgSpecanDep _ m) = put m encoder (SBPMsgSsrCodeBiases _ m) = put m + encoder (SBPMsgSsrCodePhaseBiasesBounds _ m) = put m + encoder (SBPMsgSsrFlagHighLevel _ m) = put m + encoder (SBPMsgSsrFlagIonoGridPointSatLos _ m) = put m + encoder (SBPMsgSsrFlagIonoGridPoints _ m) = put m + encoder (SBPMsgSsrFlagIonoTileSatLos _ m) = put m + encoder (SBPMsgSsrFlagSatellites _ m) = put m + encoder (SBPMsgSsrFlagTropoGridPoints _ m) = put m encoder (SBPMsgSsrGridDefinitionDepA _ m) = put m encoder (SBPMsgSsrGriddedCorrection _ m) = put m + encoder (SBPMsgSsrGriddedCorrectionBounds _ m) = put m encoder (SBPMsgSsrGriddedCorrectionDepA _ m) = put m encoder (SBPMsgSsrGriddedCorrectionNoStdDepA _ m) = put m encoder (SBPMsgSsrOrbitClock _ m) = put m + encoder (SBPMsgSsrOrbitClockBounds _ m) = put m + encoder (SBPMsgSsrOrbitClockBoundsDegradation _ m) = put m encoder (SBPMsgSsrOrbitClockDepA _ m) = put m encoder (SBPMsgSsrPhaseBiases _ m) = put m encoder (SBPMsgSsrSatelliteApc _ m) = put m encoder (SBPMsgSsrStecCorrection _ m) = put m + encoder (SBPMsgSsrStecCorrectionDep _ m) = put m encoder (SBPMsgSsrStecCorrectionDepA _ m) = put m encoder (SBPMsgSsrTileDefinition _ m) = put m + encoder (SBPMsgSsrTileDefinitionDep _ m) = put m encoder (SBPMsgStartup _ m) = put m encoder (SBPMsgStatusJournal _ m) = put m encoder (SBPMsgStatusReport _ m) = put m @@ -773,6 +816,7 @@ instance FromJSON SBPMsg where | msgType == msgGloBiases = SBPMsgGloBiases <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgGnssCapb = SBPMsgGnssCapb <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgGnssTimeOffset = SBPMsgGnssTimeOffset <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgGpsLeapSecond = SBPMsgGpsLeapSecond <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgGpsTime = SBPMsgGpsTime <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgGpsTimeDepA = SBPMsgGpsTimeDepA <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgGpsTimeGnss = SBPMsgGpsTimeGnss <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj @@ -788,6 +832,7 @@ instance FromJSON SBPMsg where | msgType == msgInsStatus = SBPMsgInsStatus <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgInsUpdates = SBPMsgInsUpdates <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgIono = SBPMsgIono <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgItrf = SBPMsgItrf <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgLinuxCpuState = SBPMsgLinuxCpuState <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgLinuxCpuStateDepA = SBPMsgLinuxCpuStateDepA <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgLinuxMemState = SBPMsgLinuxMemState <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj @@ -855,17 +900,29 @@ instance FromJSON SBPMsg where | msgType == msgSpecan = SBPMsgSpecan <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSpecanDep = SBPMsgSpecanDep <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrCodeBiases = SBPMsgSsrCodeBiases <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgSsrCodePhaseBiasesBounds = SBPMsgSsrCodePhaseBiasesBounds <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgSsrFlagHighLevel = SBPMsgSsrFlagHighLevel <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgSsrFlagIonoGridPointSatLos = SBPMsgSsrFlagIonoGridPointSatLos <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgSsrFlagIonoGridPoints = SBPMsgSsrFlagIonoGridPoints <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgSsrFlagIonoTileSatLos = SBPMsgSsrFlagIonoTileSatLos <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgSsrFlagSatellites = SBPMsgSsrFlagSatellites <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgSsrFlagTropoGridPoints = SBPMsgSsrFlagTropoGridPoints <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrGridDefinitionDepA = SBPMsgSsrGridDefinitionDepA <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrGriddedCorrection = SBPMsgSsrGriddedCorrection <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgSsrGriddedCorrectionBounds = SBPMsgSsrGriddedCorrectionBounds <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrGriddedCorrectionDepA = SBPMsgSsrGriddedCorrectionDepA <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrGriddedCorrectionNoStdDepA = SBPMsgSsrGriddedCorrectionNoStdDepA <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrOrbitClock = SBPMsgSsrOrbitClock <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgSsrOrbitClockBounds = SBPMsgSsrOrbitClockBounds <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgSsrOrbitClockBoundsDegradation = SBPMsgSsrOrbitClockBoundsDegradation <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrOrbitClockDepA = SBPMsgSsrOrbitClockDepA <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrPhaseBiases = SBPMsgSsrPhaseBiases <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrSatelliteApc = SBPMsgSsrSatelliteApc <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrStecCorrection = SBPMsgSsrStecCorrection <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgSsrStecCorrectionDep = SBPMsgSsrStecCorrectionDep <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrStecCorrectionDepA = SBPMsgSsrStecCorrectionDepA <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrTileDefinition = SBPMsgSsrTileDefinition <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgSsrTileDefinitionDep = SBPMsgSsrTileDefinitionDep <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgStartup = SBPMsgStartup <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgStatusJournal = SBPMsgStatusJournal <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgStatusReport = SBPMsgStatusReport <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj @@ -988,6 +1045,7 @@ instance ToJSON SBPMsg where toJSON (SBPMsgGloBiases n m) = toJSON n <<>> toJSON m toJSON (SBPMsgGnssCapb n m) = toJSON n <<>> toJSON m toJSON (SBPMsgGnssTimeOffset n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgGpsLeapSecond n m) = toJSON n <<>> toJSON m toJSON (SBPMsgGpsTime n m) = toJSON n <<>> toJSON m toJSON (SBPMsgGpsTimeDepA n m) = toJSON n <<>> toJSON m toJSON (SBPMsgGpsTimeGnss n m) = toJSON n <<>> toJSON m @@ -1003,6 +1061,7 @@ instance ToJSON SBPMsg where toJSON (SBPMsgInsStatus n m) = toJSON n <<>> toJSON m toJSON (SBPMsgInsUpdates n m) = toJSON n <<>> toJSON m toJSON (SBPMsgIono n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgItrf n m) = toJSON n <<>> toJSON m toJSON (SBPMsgLinuxCpuState n m) = toJSON n <<>> toJSON m toJSON (SBPMsgLinuxCpuStateDepA n m) = toJSON n <<>> toJSON m toJSON (SBPMsgLinuxMemState n m) = toJSON n <<>> toJSON m @@ -1070,17 +1129,29 @@ instance ToJSON SBPMsg where toJSON (SBPMsgSpecan n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSpecanDep n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrCodeBiases n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgSsrCodePhaseBiasesBounds n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgSsrFlagHighLevel n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgSsrFlagIonoGridPointSatLos n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgSsrFlagIonoGridPoints n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgSsrFlagIonoTileSatLos n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgSsrFlagSatellites n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgSsrFlagTropoGridPoints n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrGridDefinitionDepA n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrGriddedCorrection n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgSsrGriddedCorrectionBounds n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrGriddedCorrectionDepA n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrGriddedCorrectionNoStdDepA n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrOrbitClock n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgSsrOrbitClockBounds n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgSsrOrbitClockBoundsDegradation n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrOrbitClockDepA n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrPhaseBiases n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrSatelliteApc n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrStecCorrection n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgSsrStecCorrectionDep n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrStecCorrectionDepA n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrTileDefinition n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgSsrTileDefinitionDep n m) = toJSON n <<>> toJSON m toJSON (SBPMsgStartup n m) = toJSON n <<>> toJSON m toJSON (SBPMsgStatusJournal n m) = toJSON n <<>> toJSON m toJSON (SBPMsgStatusReport n m) = toJSON n <<>> toJSON m @@ -1197,6 +1268,7 @@ instance HasMsg SBPMsg where msg f (SBPMsgGloBiases n m) = SBPMsgGloBiases n <$> f m msg f (SBPMsgGnssCapb n m) = SBPMsgGnssCapb n <$> f m msg f (SBPMsgGnssTimeOffset n m) = SBPMsgGnssTimeOffset n <$> f m + msg f (SBPMsgGpsLeapSecond n m) = SBPMsgGpsLeapSecond n <$> f m msg f (SBPMsgGpsTime n m) = SBPMsgGpsTime n <$> f m msg f (SBPMsgGpsTimeDepA n m) = SBPMsgGpsTimeDepA n <$> f m msg f (SBPMsgGpsTimeGnss n m) = SBPMsgGpsTimeGnss n <$> f m @@ -1212,6 +1284,7 @@ instance HasMsg SBPMsg where msg f (SBPMsgInsStatus n m) = SBPMsgInsStatus n <$> f m msg f (SBPMsgInsUpdates n m) = SBPMsgInsUpdates n <$> f m msg f (SBPMsgIono n m) = SBPMsgIono n <$> f m + msg f (SBPMsgItrf n m) = SBPMsgItrf n <$> f m msg f (SBPMsgLinuxCpuState n m) = SBPMsgLinuxCpuState n <$> f m msg f (SBPMsgLinuxCpuStateDepA n m) = SBPMsgLinuxCpuStateDepA n <$> f m msg f (SBPMsgLinuxMemState n m) = SBPMsgLinuxMemState n <$> f m @@ -1279,17 +1352,29 @@ instance HasMsg SBPMsg where msg f (SBPMsgSpecan n m) = SBPMsgSpecan n <$> f m msg f (SBPMsgSpecanDep n m) = SBPMsgSpecanDep n <$> f m msg f (SBPMsgSsrCodeBiases n m) = SBPMsgSsrCodeBiases n <$> f m + msg f (SBPMsgSsrCodePhaseBiasesBounds n m) = SBPMsgSsrCodePhaseBiasesBounds n <$> f m + msg f (SBPMsgSsrFlagHighLevel n m) = SBPMsgSsrFlagHighLevel n <$> f m + msg f (SBPMsgSsrFlagIonoGridPointSatLos n m) = SBPMsgSsrFlagIonoGridPointSatLos n <$> f m + msg f (SBPMsgSsrFlagIonoGridPoints n m) = SBPMsgSsrFlagIonoGridPoints n <$> f m + msg f (SBPMsgSsrFlagIonoTileSatLos n m) = SBPMsgSsrFlagIonoTileSatLos n <$> f m + msg f (SBPMsgSsrFlagSatellites n m) = SBPMsgSsrFlagSatellites n <$> f m + msg f (SBPMsgSsrFlagTropoGridPoints n m) = SBPMsgSsrFlagTropoGridPoints n <$> f m msg f (SBPMsgSsrGridDefinitionDepA n m) = SBPMsgSsrGridDefinitionDepA n <$> f m msg f (SBPMsgSsrGriddedCorrection n m) = SBPMsgSsrGriddedCorrection n <$> f m + msg f (SBPMsgSsrGriddedCorrectionBounds n m) = SBPMsgSsrGriddedCorrectionBounds n <$> f m msg f (SBPMsgSsrGriddedCorrectionDepA n m) = SBPMsgSsrGriddedCorrectionDepA n <$> f m msg f (SBPMsgSsrGriddedCorrectionNoStdDepA n m) = SBPMsgSsrGriddedCorrectionNoStdDepA n <$> f m msg f (SBPMsgSsrOrbitClock n m) = SBPMsgSsrOrbitClock n <$> f m + msg f (SBPMsgSsrOrbitClockBounds n m) = SBPMsgSsrOrbitClockBounds n <$> f m + msg f (SBPMsgSsrOrbitClockBoundsDegradation n m) = SBPMsgSsrOrbitClockBoundsDegradation n <$> f m msg f (SBPMsgSsrOrbitClockDepA n m) = SBPMsgSsrOrbitClockDepA n <$> f m msg f (SBPMsgSsrPhaseBiases n m) = SBPMsgSsrPhaseBiases n <$> f m msg f (SBPMsgSsrSatelliteApc n m) = SBPMsgSsrSatelliteApc n <$> f m msg f (SBPMsgSsrStecCorrection n m) = SBPMsgSsrStecCorrection n <$> f m + msg f (SBPMsgSsrStecCorrectionDep n m) = SBPMsgSsrStecCorrectionDep n <$> f m msg f (SBPMsgSsrStecCorrectionDepA n m) = SBPMsgSsrStecCorrectionDepA n <$> f m msg f (SBPMsgSsrTileDefinition n m) = SBPMsgSsrTileDefinition n <$> f m + msg f (SBPMsgSsrTileDefinitionDep n m) = SBPMsgSsrTileDefinitionDep n <$> f m msg f (SBPMsgStartup n m) = SBPMsgStartup n <$> f m msg f (SBPMsgStatusJournal n m) = SBPMsgStatusJournal n <$> f m msg f (SBPMsgStatusReport n m) = SBPMsgStatusReport n <$> f m diff --git a/haskell/src/SwiftNav/SBP/Navigation.hs b/haskell/src/SwiftNav/SBP/Navigation.hs index b32d086ed9..f212fdd6f8 100644 --- a/haskell/src/SwiftNav/SBP/Navigation.hs +++ b/haskell/src/SwiftNav/SBP/Navigation.hs @@ -2303,3 +2303,45 @@ instance Binary MsgProtectionLevel where $(makeSBP 'msgProtectionLevel ''MsgProtectionLevel) $(makeJSON "_msgProtectionLevel_" ''MsgProtectionLevel) $(makeLenses ''MsgProtectionLevel) + +msgGpsLeapSecond :: Word16 +msgGpsLeapSecond = 0x023A + +-- | SBP class for message MSG_GPS_LEAP_SECOND (0x023A). +-- +-- Emulates the GPS CNAV message, reserving bytes for future broadcast of the +-- drift model parameters. +data MsgGpsLeapSecond = MsgGpsLeapSecond + { _msgGpsLeapSecond_stub :: ![Word8] + } deriving ( Show, Read, Eq ) + +instance Binary MsgGpsLeapSecond where + get = do + _msgGpsLeapSecond_stub <- whileM (not <$> isEmpty) getWord8 + pure MsgGpsLeapSecond {..} + + put MsgGpsLeapSecond {..} = do + mapM_ putWord8 _msgGpsLeapSecond_stub + +$(makeSBP 'msgGpsLeapSecond ''MsgGpsLeapSecond) +$(makeJSON "_msgGpsLeapSecond_" ''MsgGpsLeapSecond) +$(makeLenses ''MsgGpsLeapSecond) + +msgItrf :: Word16 +msgItrf = 0x0244 + +data MsgItrf = MsgItrf + { _msgItrf_stub :: ![Word8] + } deriving ( Show, Read, Eq ) + +instance Binary MsgItrf where + get = do + _msgItrf_stub <- whileM (not <$> isEmpty) getWord8 + pure MsgItrf {..} + + put MsgItrf {..} = do + mapM_ putWord8 _msgItrf_stub + +$(makeSBP 'msgItrf ''MsgItrf) +$(makeJSON "_msgItrf_" ''MsgItrf) +$(makeLenses ''MsgItrf) diff --git a/haskell/src/SwiftNav/SBP/Ssr.hs b/haskell/src/SwiftNav/SBP/Ssr.hs index 2088f49a44..d975896b86 100644 --- a/haskell/src/SwiftNav/SBP/Ssr.hs +++ b/haskell/src/SwiftNav/SBP/Ssr.hs @@ -507,10 +507,10 @@ $(makeSBP 'msgSsrPhaseBiases ''MsgSsrPhaseBiases) $(makeJSON "_msgSsrPhaseBiases_" ''MsgSsrPhaseBiases) $(makeLenses ''MsgSsrPhaseBiases) -msgSsrStecCorrection :: Word16 -msgSsrStecCorrection = 0x05FB +msgSsrStecCorrectionDep :: Word16 +msgSsrStecCorrectionDep = 0x05FB --- | SBP class for message MSG_SSR_STEC_CORRECTION (0x05FB). +-- | SBP class for message MSG_SSR_STEC_CORRECTION_DEP (0x05FB). -- -- The Slant Total Electron Content per space vehicle, given as polynomial -- approximation for a given tile. This should be combined with the @@ -518,22 +518,41 @@ msgSsrStecCorrection = 0x05FB -- the atmospheric delay. -- -- It is typically equivalent to the QZSS CLAS Sub Type 8 messages. -data MsgSsrStecCorrection = MsgSsrStecCorrection - { _msgSsrStecCorrection_header :: !STECHeader +data MsgSsrStecCorrectionDep = MsgSsrStecCorrectionDep + { _msgSsrStecCorrectionDep_header :: !STECHeader -- ^ Header of a STEC polynomial coefficient message. - , _msgSsrStecCorrection_stec_sat_list :: ![STECSatElement] + , _msgSsrStecCorrectionDep_stec_sat_list :: ![STECSatElement] -- ^ Array of STEC polynomial coefficients for each space vehicle. } deriving ( Show, Read, Eq ) +instance Binary MsgSsrStecCorrectionDep where + get = do + _msgSsrStecCorrectionDep_header <- get + _msgSsrStecCorrectionDep_stec_sat_list <- whileM (not <$> isEmpty) get + pure MsgSsrStecCorrectionDep {..} + + put MsgSsrStecCorrectionDep {..} = do + put _msgSsrStecCorrectionDep_header + mapM_ put _msgSsrStecCorrectionDep_stec_sat_list + +$(makeSBP 'msgSsrStecCorrectionDep ''MsgSsrStecCorrectionDep) +$(makeJSON "_msgSsrStecCorrectionDep_" ''MsgSsrStecCorrectionDep) +$(makeLenses ''MsgSsrStecCorrectionDep) + +msgSsrStecCorrection :: Word16 +msgSsrStecCorrection = 0x05FD + +data MsgSsrStecCorrection = MsgSsrStecCorrection + { _msgSsrStecCorrection_stub :: ![Word8] + } deriving ( Show, Read, Eq ) + instance Binary MsgSsrStecCorrection where get = do - _msgSsrStecCorrection_header <- get - _msgSsrStecCorrection_stec_sat_list <- whileM (not <$> isEmpty) get + _msgSsrStecCorrection_stub <- whileM (not <$> isEmpty) getWord8 pure MsgSsrStecCorrection {..} put MsgSsrStecCorrection {..} = do - put _msgSsrStecCorrection_header - mapM_ put _msgSsrStecCorrection_stec_sat_list + mapM_ putWord8 _msgSsrStecCorrection_stub $(makeSBP 'msgSsrStecCorrection ''MsgSsrStecCorrection) $(makeJSON "_msgSsrStecCorrection_" ''MsgSsrStecCorrection) @@ -576,25 +595,44 @@ $(makeSBP 'msgSsrGriddedCorrection ''MsgSsrGriddedCorrection) $(makeJSON "_msgSsrGriddedCorrection_" ''MsgSsrGriddedCorrection) $(makeLenses ''MsgSsrGriddedCorrection) -msgSsrTileDefinition :: Word16 -msgSsrTileDefinition = 0x05F6 +msgSsrGriddedCorrectionBounds :: Word16 +msgSsrGriddedCorrectionBounds = 0x05FE --- | SBP class for message MSG_SSR_TILE_DEFINITION (0x05F6). +data MsgSsrGriddedCorrectionBounds = MsgSsrGriddedCorrectionBounds + { _msgSsrGriddedCorrectionBounds_stub :: ![Word8] + } deriving ( Show, Read, Eq ) + +instance Binary MsgSsrGriddedCorrectionBounds where + get = do + _msgSsrGriddedCorrectionBounds_stub <- whileM (not <$> isEmpty) getWord8 + pure MsgSsrGriddedCorrectionBounds {..} + + put MsgSsrGriddedCorrectionBounds {..} = do + mapM_ putWord8 _msgSsrGriddedCorrectionBounds_stub + +$(makeSBP 'msgSsrGriddedCorrectionBounds ''MsgSsrGriddedCorrectionBounds) +$(makeJSON "_msgSsrGriddedCorrectionBounds_" ''MsgSsrGriddedCorrectionBounds) +$(makeLenses ''MsgSsrGriddedCorrectionBounds) + +msgSsrTileDefinitionDep :: Word16 +msgSsrTileDefinitionDep = 0x05F6 + +-- | SBP class for message MSG_SSR_TILE_DEFINITION_DEP (0x05F6). -- -- Provides the correction point coordinates for the atmospheric correction --- values in the MSG_SSR_STEC_CORRECTION and MSG_SSR_GRIDDED_CORRECTION +-- values in the MSG_SSR_STEC_CORRECTION_DEP and MSG_SSR_GRIDDED_CORRECTION -- messages. -- -- Based on ETSI TS 137 355 V16.1.0 (LTE Positioning Protocol) information -- element GNSS-SSR-CorrectionPoints. SBP only supports gridded arrays of -- correction points, not lists of points. -data MsgSsrTileDefinition = MsgSsrTileDefinition - { _msgSsrTileDefinition_tile_set_id :: !Word16 +data MsgSsrTileDefinitionDep = MsgSsrTileDefinitionDep + { _msgSsrTileDefinitionDep_tile_set_id :: !Word16 -- ^ Unique identifier of the tile set this tile belongs to. - , _msgSsrTileDefinition_tile_id :: !Word16 + , _msgSsrTileDefinitionDep_tile_id :: !Word16 -- ^ Unique identifier of this tile in the tile set. -- See GNSS-SSR-ArrayOfCorrectionPoints field correctionPointSetID. - , _msgSsrTileDefinition_corner_nw_lat :: !Int16 + , _msgSsrTileDefinitionDep_corner_nw_lat :: !Int16 -- ^ North-West corner correction point latitude. -- -- The relation between the latitude X in the range [-90, 90] and the @@ -603,7 +641,7 @@ data MsgSsrTileDefinition = MsgSsrTileDefinition -- N = floor((X / 90) * 2^14) -- -- See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLatitude. - , _msgSsrTileDefinition_corner_nw_lon :: !Int16 + , _msgSsrTileDefinitionDep_corner_nw_lon :: !Int16 -- ^ North-West corner correction point longitude. -- -- The relation between the longitude X in the range [-180, 180] and the @@ -612,23 +650,23 @@ data MsgSsrTileDefinition = MsgSsrTileDefinition -- N = floor((X / 180) * 2^15) -- -- See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLongitude. - , _msgSsrTileDefinition_spacing_lat :: !Word16 + , _msgSsrTileDefinitionDep_spacing_lat :: !Word16 -- ^ Spacing of the correction points in the latitude direction. -- -- See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLatitude. - , _msgSsrTileDefinition_spacing_lon :: !Word16 + , _msgSsrTileDefinitionDep_spacing_lon :: !Word16 -- ^ Spacing of the correction points in the longitude direction. -- -- See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLongitude. - , _msgSsrTileDefinition_rows :: !Word16 + , _msgSsrTileDefinitionDep_rows :: !Word16 -- ^ Number of steps in the latitude direction. -- -- See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLatitude. - , _msgSsrTileDefinition_cols :: !Word16 + , _msgSsrTileDefinitionDep_cols :: !Word16 -- ^ Number of steps in the longitude direction. -- -- See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLongitude. - , _msgSsrTileDefinition_bitmask :: !Word64 + , _msgSsrTileDefinitionDep_bitmask :: !Word64 -- ^ Specifies the availability of correction data at the correction points -- in the array. -- @@ -646,29 +684,57 @@ data MsgSsrTileDefinition = MsgSsrTileDefinition -- definition of the bits is inverted. } deriving ( Show, Read, Eq ) +instance Binary MsgSsrTileDefinitionDep where + get = do + _msgSsrTileDefinitionDep_tile_set_id <- getWord16le + _msgSsrTileDefinitionDep_tile_id <- getWord16le + _msgSsrTileDefinitionDep_corner_nw_lat <- (fromIntegral <$> getWord16le) + _msgSsrTileDefinitionDep_corner_nw_lon <- (fromIntegral <$> getWord16le) + _msgSsrTileDefinitionDep_spacing_lat <- getWord16le + _msgSsrTileDefinitionDep_spacing_lon <- getWord16le + _msgSsrTileDefinitionDep_rows <- getWord16le + _msgSsrTileDefinitionDep_cols <- getWord16le + _msgSsrTileDefinitionDep_bitmask <- getWord64le + pure MsgSsrTileDefinitionDep {..} + + put MsgSsrTileDefinitionDep {..} = do + putWord16le _msgSsrTileDefinitionDep_tile_set_id + putWord16le _msgSsrTileDefinitionDep_tile_id + (putWord16le . fromIntegral) _msgSsrTileDefinitionDep_corner_nw_lat + (putWord16le . fromIntegral) _msgSsrTileDefinitionDep_corner_nw_lon + putWord16le _msgSsrTileDefinitionDep_spacing_lat + putWord16le _msgSsrTileDefinitionDep_spacing_lon + putWord16le _msgSsrTileDefinitionDep_rows + putWord16le _msgSsrTileDefinitionDep_cols + putWord64le _msgSsrTileDefinitionDep_bitmask + +$(makeSBP 'msgSsrTileDefinitionDep ''MsgSsrTileDefinitionDep) +$(makeJSON "_msgSsrTileDefinitionDep_" ''MsgSsrTileDefinitionDep) +$(makeLenses ''MsgSsrTileDefinitionDep) + +msgSsrTileDefinition :: Word16 +msgSsrTileDefinition = 0x05F7 + +-- | SBP class for message MSG_SSR_TILE_DEFINITION (0x05F7). +-- +-- Provides the correction point coordinates for the atmospheric correction +-- values in the MSG_SSR_STEC_CORRECTION and MSG_SSR_GRIDDED_CORRECTION +-- messages. +-- +-- Based on ETSI TS 137 355 V16.1.0 (LTE Positioning Protocol) information +-- element GNSS-SSR-CorrectionPoints. SBP only supports gridded arrays of +-- correction points, not lists of points. +data MsgSsrTileDefinition = MsgSsrTileDefinition + { _msgSsrTileDefinition_stub :: ![Word8] + } deriving ( Show, Read, Eq ) + instance Binary MsgSsrTileDefinition where get = do - _msgSsrTileDefinition_tile_set_id <- getWord16le - _msgSsrTileDefinition_tile_id <- getWord16le - _msgSsrTileDefinition_corner_nw_lat <- (fromIntegral <$> getWord16le) - _msgSsrTileDefinition_corner_nw_lon <- (fromIntegral <$> getWord16le) - _msgSsrTileDefinition_spacing_lat <- getWord16le - _msgSsrTileDefinition_spacing_lon <- getWord16le - _msgSsrTileDefinition_rows <- getWord16le - _msgSsrTileDefinition_cols <- getWord16le - _msgSsrTileDefinition_bitmask <- getWord64le + _msgSsrTileDefinition_stub <- whileM (not <$> isEmpty) getWord8 pure MsgSsrTileDefinition {..} put MsgSsrTileDefinition {..} = do - putWord16le _msgSsrTileDefinition_tile_set_id - putWord16le _msgSsrTileDefinition_tile_id - (putWord16le . fromIntegral) _msgSsrTileDefinition_corner_nw_lat - (putWord16le . fromIntegral) _msgSsrTileDefinition_corner_nw_lon - putWord16le _msgSsrTileDefinition_spacing_lat - putWord16le _msgSsrTileDefinition_spacing_lon - putWord16le _msgSsrTileDefinition_rows - putWord16le _msgSsrTileDefinition_cols - putWord64le _msgSsrTileDefinition_bitmask + mapM_ putWord8 _msgSsrTileDefinition_stub $(makeSBP 'msgSsrTileDefinition ''MsgSsrTileDefinition) $(makeJSON "_msgSsrTileDefinition_" ''MsgSsrTileDefinition) @@ -1043,3 +1109,60 @@ instance Binary MsgSsrGridDefinitionDepA where $(makeSBP 'msgSsrGridDefinitionDepA ''MsgSsrGridDefinitionDepA) $(makeJSON "_msgSsrGridDefinitionDepA_" ''MsgSsrGridDefinitionDepA) $(makeLenses ''MsgSsrGridDefinitionDepA) + +msgSsrOrbitClockBounds :: Word16 +msgSsrOrbitClockBounds = 0x05DE + +data MsgSsrOrbitClockBounds = MsgSsrOrbitClockBounds + { _msgSsrOrbitClockBounds_stub :: ![Word8] + } deriving ( Show, Read, Eq ) + +instance Binary MsgSsrOrbitClockBounds where + get = do + _msgSsrOrbitClockBounds_stub <- whileM (not <$> isEmpty) getWord8 + pure MsgSsrOrbitClockBounds {..} + + put MsgSsrOrbitClockBounds {..} = do + mapM_ putWord8 _msgSsrOrbitClockBounds_stub + +$(makeSBP 'msgSsrOrbitClockBounds ''MsgSsrOrbitClockBounds) +$(makeJSON "_msgSsrOrbitClockBounds_" ''MsgSsrOrbitClockBounds) +$(makeLenses ''MsgSsrOrbitClockBounds) + +msgSsrCodePhaseBiasesBounds :: Word16 +msgSsrCodePhaseBiasesBounds = 0x05EC + +data MsgSsrCodePhaseBiasesBounds = MsgSsrCodePhaseBiasesBounds + { _msgSsrCodePhaseBiasesBounds_stub :: ![Word8] + } deriving ( Show, Read, Eq ) + +instance Binary MsgSsrCodePhaseBiasesBounds where + get = do + _msgSsrCodePhaseBiasesBounds_stub <- whileM (not <$> isEmpty) getWord8 + pure MsgSsrCodePhaseBiasesBounds {..} + + put MsgSsrCodePhaseBiasesBounds {..} = do + mapM_ putWord8 _msgSsrCodePhaseBiasesBounds_stub + +$(makeSBP 'msgSsrCodePhaseBiasesBounds ''MsgSsrCodePhaseBiasesBounds) +$(makeJSON "_msgSsrCodePhaseBiasesBounds_" ''MsgSsrCodePhaseBiasesBounds) +$(makeLenses ''MsgSsrCodePhaseBiasesBounds) + +msgSsrOrbitClockBoundsDegradation :: Word16 +msgSsrOrbitClockBoundsDegradation = 0x05DF + +data MsgSsrOrbitClockBoundsDegradation = MsgSsrOrbitClockBoundsDegradation + { _msgSsrOrbitClockBoundsDegradation_stub :: ![Word8] + } deriving ( Show, Read, Eq ) + +instance Binary MsgSsrOrbitClockBoundsDegradation where + get = do + _msgSsrOrbitClockBoundsDegradation_stub <- whileM (not <$> isEmpty) getWord8 + pure MsgSsrOrbitClockBoundsDegradation {..} + + put MsgSsrOrbitClockBoundsDegradation {..} = do + mapM_ putWord8 _msgSsrOrbitClockBoundsDegradation_stub + +$(makeSBP 'msgSsrOrbitClockBoundsDegradation ''MsgSsrOrbitClockBoundsDegradation) +$(makeJSON "_msgSsrOrbitClockBoundsDegradation_" ''MsgSsrOrbitClockBoundsDegradation) +$(makeLenses ''MsgSsrOrbitClockBoundsDegradation) diff --git a/java/src/com/swiftnav/sbp/client/MessageTable.java b/java/src/com/swiftnav/sbp/client/MessageTable.java index 41bc31601d..336cd19b2f 100644 --- a/java/src/com/swiftnav/sbp/client/MessageTable.java +++ b/java/src/com/swiftnav/sbp/client/MessageTable.java @@ -47,6 +47,12 @@ import com.swiftnav.sbp.flash.MsgStmUniqueIdResp; import com.swiftnav.sbp.imu.MsgImuAux; import com.swiftnav.sbp.imu.MsgImuRaw; +import com.swiftnav.sbp.integrity.MsgSsrFlagHighLevel; +import com.swiftnav.sbp.integrity.MsgSsrFlagIonoGridPointSatLos; +import com.swiftnav.sbp.integrity.MsgSsrFlagIonoGridPoints; +import com.swiftnav.sbp.integrity.MsgSsrFlagIonoTileSatLos; +import com.swiftnav.sbp.integrity.MsgSsrFlagSatellites; +import com.swiftnav.sbp.integrity.MsgSsrFlagTropoGridPoints; import com.swiftnav.sbp.linux.MsgLinuxCpuState; import com.swiftnav.sbp.linux.MsgLinuxCpuStateDepA; import com.swiftnav.sbp.linux.MsgLinuxMemState; @@ -70,9 +76,11 @@ import com.swiftnav.sbp.navigation.MsgBaselineNEDDepA; import com.swiftnav.sbp.navigation.MsgDops; import com.swiftnav.sbp.navigation.MsgDopsDepA; +import com.swiftnav.sbp.navigation.MsgGPSLeapSecond; import com.swiftnav.sbp.navigation.MsgGPSTime; import com.swiftnav.sbp.navigation.MsgGPSTimeDepA; import com.swiftnav.sbp.navigation.MsgGPSTimeGnss; +import com.swiftnav.sbp.navigation.MsgItrf; import com.swiftnav.sbp.navigation.MsgPosECEF; import com.swiftnav.sbp.navigation.MsgPosECEFCov; import com.swiftnav.sbp.navigation.MsgPosECEFCovGnss; @@ -182,17 +190,23 @@ import com.swiftnav.sbp.solution_meta.MsgSolnMeta; import com.swiftnav.sbp.solution_meta.MsgSolnMetaDepA; import com.swiftnav.sbp.ssr.MsgSsrCodeBiases; +import com.swiftnav.sbp.ssr.MsgSsrCodePhaseBiasesBounds; import com.swiftnav.sbp.ssr.MsgSsrGridDefinitionDepA; import com.swiftnav.sbp.ssr.MsgSsrGriddedCorrection; +import com.swiftnav.sbp.ssr.MsgSsrGriddedCorrectionBounds; import com.swiftnav.sbp.ssr.MsgSsrGriddedCorrectionDepA; import com.swiftnav.sbp.ssr.MsgSsrGriddedCorrectionNoStdDepA; import com.swiftnav.sbp.ssr.MsgSsrOrbitClock; +import com.swiftnav.sbp.ssr.MsgSsrOrbitClockBounds; +import com.swiftnav.sbp.ssr.MsgSsrOrbitClockBoundsDegradation; import com.swiftnav.sbp.ssr.MsgSsrOrbitClockDepA; import com.swiftnav.sbp.ssr.MsgSsrPhaseBiases; import com.swiftnav.sbp.ssr.MsgSsrSatelliteApc; import com.swiftnav.sbp.ssr.MsgSsrStecCorrection; +import com.swiftnav.sbp.ssr.MsgSsrStecCorrectionDep; import com.swiftnav.sbp.ssr.MsgSsrStecCorrectionDepA; import com.swiftnav.sbp.ssr.MsgSsrTileDefinition; +import com.swiftnav.sbp.ssr.MsgSsrTileDefinitionDep; import com.swiftnav.sbp.system.MsgCsacTelemetry; import com.swiftnav.sbp.system.MsgCsacTelemetryLabels; import com.swiftnav.sbp.system.MsgDgnssStatus; @@ -290,6 +304,18 @@ static SBPMessage dispatch(SBPMessage msg) throws SBPBinaryException { return new MsgImuRaw(msg); case MsgImuAux.TYPE: return new MsgImuAux(msg); + case MsgSsrFlagHighLevel.TYPE: + return new MsgSsrFlagHighLevel(msg); + case MsgSsrFlagSatellites.TYPE: + return new MsgSsrFlagSatellites(msg); + case MsgSsrFlagTropoGridPoints.TYPE: + return new MsgSsrFlagTropoGridPoints(msg); + case MsgSsrFlagIonoGridPoints.TYPE: + return new MsgSsrFlagIonoGridPoints(msg); + case MsgSsrFlagIonoTileSatLos.TYPE: + return new MsgSsrFlagIonoTileSatLos(msg); + case MsgSsrFlagIonoGridPointSatLos.TYPE: + return new MsgSsrFlagIonoGridPointSatLos(msg); case MsgLinuxCpuStateDepA.TYPE: return new MsgLinuxCpuStateDepA(msg); case MsgLinuxMemStateDepA.TYPE: @@ -396,6 +422,10 @@ static SBPMessage dispatch(SBPMessage msg) throws SBPBinaryException { return new MsgProtectionLevelDepA(msg); case MsgProtectionLevel.TYPE: return new MsgProtectionLevel(msg); + case MsgGPSLeapSecond.TYPE: + return new MsgGPSLeapSecond(msg); + case MsgItrf.TYPE: + return new MsgItrf(msg); case MsgNdbEvent.TYPE: return new MsgNdbEvent(msg); case MsgObs.TYPE: @@ -564,10 +594,16 @@ static SBPMessage dispatch(SBPMessage msg) throws SBPBinaryException { return new MsgSsrCodeBiases(msg); case MsgSsrPhaseBiases.TYPE: return new MsgSsrPhaseBiases(msg); + case MsgSsrStecCorrectionDep.TYPE: + return new MsgSsrStecCorrectionDep(msg); case MsgSsrStecCorrection.TYPE: return new MsgSsrStecCorrection(msg); case MsgSsrGriddedCorrection.TYPE: return new MsgSsrGriddedCorrection(msg); + case MsgSsrGriddedCorrectionBounds.TYPE: + return new MsgSsrGriddedCorrectionBounds(msg); + case MsgSsrTileDefinitionDep.TYPE: + return new MsgSsrTileDefinitionDep(msg); case MsgSsrTileDefinition.TYPE: return new MsgSsrTileDefinition(msg); case MsgSsrSatelliteApc.TYPE: @@ -582,6 +618,12 @@ static SBPMessage dispatch(SBPMessage msg) throws SBPBinaryException { return new MsgSsrGriddedCorrectionDepA(msg); case MsgSsrGridDefinitionDepA.TYPE: return new MsgSsrGridDefinitionDepA(msg); + case MsgSsrOrbitClockBounds.TYPE: + return new MsgSsrOrbitClockBounds(msg); + case MsgSsrCodePhaseBiasesBounds.TYPE: + return new MsgSsrCodePhaseBiasesBounds(msg); + case MsgSsrOrbitClockBoundsDegradation.TYPE: + return new MsgSsrOrbitClockBoundsDegradation(msg); case MsgStartup.TYPE: return new MsgStartup(msg); case MsgDgnssStatus.TYPE: diff --git a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevel.java b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevel.java new file mode 100644 index 0000000000..07fdfaa27a --- /dev/null +++ b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevel.java @@ -0,0 +1,58 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.integrity; + +// This file was auto-generated from yaml/swiftnav/sbp/integrity.yaml by generate.py. +// Do not modify by hand! + + +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.gnss.*; +import org.json.JSONArray; +import org.json.JSONObject; + +public class MsgSsrFlagHighLevel extends SBPMessage { + public static final int TYPE = 0x0BB9; + + public int[] stub; + + public MsgSsrFlagHighLevel(int sender) { + super(sender, TYPE); + } + + public MsgSsrFlagHighLevel() { + super(TYPE); + } + + public MsgSsrFlagHighLevel(SBPMessage msg) throws SBPBinaryException { + super(msg); + assert msg.type == TYPE; + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + stub = parser.getArrayofU8(); + } + + @Override + protected void build(Builder builder) { + builder.putArrayofU8(stub); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("stub", new JSONArray(stub)); + return obj; + } +} diff --git a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoGridPointSatLos.java b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoGridPointSatLos.java new file mode 100644 index 0000000000..48460030cb --- /dev/null +++ b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoGridPointSatLos.java @@ -0,0 +1,58 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.integrity; + +// This file was auto-generated from yaml/swiftnav/sbp/integrity.yaml by generate.py. +// Do not modify by hand! + + +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.gnss.*; +import org.json.JSONArray; +import org.json.JSONObject; + +public class MsgSsrFlagIonoGridPointSatLos extends SBPMessage { + public static final int TYPE = 0x0BD1; + + public int[] stub; + + public MsgSsrFlagIonoGridPointSatLos(int sender) { + super(sender, TYPE); + } + + public MsgSsrFlagIonoGridPointSatLos() { + super(TYPE); + } + + public MsgSsrFlagIonoGridPointSatLos(SBPMessage msg) throws SBPBinaryException { + super(msg); + assert msg.type == TYPE; + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + stub = parser.getArrayofU8(); + } + + @Override + protected void build(Builder builder) { + builder.putArrayofU8(stub); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("stub", new JSONArray(stub)); + return obj; + } +} diff --git a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoGridPoints.java b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoGridPoints.java new file mode 100644 index 0000000000..0eb5c746da --- /dev/null +++ b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoGridPoints.java @@ -0,0 +1,58 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.integrity; + +// This file was auto-generated from yaml/swiftnav/sbp/integrity.yaml by generate.py. +// Do not modify by hand! + + +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.gnss.*; +import org.json.JSONArray; +import org.json.JSONObject; + +public class MsgSsrFlagIonoGridPoints extends SBPMessage { + public static final int TYPE = 0x0BC7; + + public int[] stub; + + public MsgSsrFlagIonoGridPoints(int sender) { + super(sender, TYPE); + } + + public MsgSsrFlagIonoGridPoints() { + super(TYPE); + } + + public MsgSsrFlagIonoGridPoints(SBPMessage msg) throws SBPBinaryException { + super(msg); + assert msg.type == TYPE; + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + stub = parser.getArrayofU8(); + } + + @Override + protected void build(Builder builder) { + builder.putArrayofU8(stub); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("stub", new JSONArray(stub)); + return obj; + } +} diff --git a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoTileSatLos.java b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoTileSatLos.java new file mode 100644 index 0000000000..029eab5c79 --- /dev/null +++ b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoTileSatLos.java @@ -0,0 +1,58 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.integrity; + +// This file was auto-generated from yaml/swiftnav/sbp/integrity.yaml by generate.py. +// Do not modify by hand! + + +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.gnss.*; +import org.json.JSONArray; +import org.json.JSONObject; + +public class MsgSsrFlagIonoTileSatLos extends SBPMessage { + public static final int TYPE = 0x0BCD; + + public int[] stub; + + public MsgSsrFlagIonoTileSatLos(int sender) { + super(sender, TYPE); + } + + public MsgSsrFlagIonoTileSatLos() { + super(TYPE); + } + + public MsgSsrFlagIonoTileSatLos(SBPMessage msg) throws SBPBinaryException { + super(msg); + assert msg.type == TYPE; + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + stub = parser.getArrayofU8(); + } + + @Override + protected void build(Builder builder) { + builder.putArrayofU8(stub); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("stub", new JSONArray(stub)); + return obj; + } +} diff --git a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagSatellites.java b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagSatellites.java new file mode 100644 index 0000000000..c80fee54fd --- /dev/null +++ b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagSatellites.java @@ -0,0 +1,58 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.integrity; + +// This file was auto-generated from yaml/swiftnav/sbp/integrity.yaml by generate.py. +// Do not modify by hand! + + +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.gnss.*; +import org.json.JSONArray; +import org.json.JSONObject; + +public class MsgSsrFlagSatellites extends SBPMessage { + public static final int TYPE = 0x0BBD; + + public int[] stub; + + public MsgSsrFlagSatellites(int sender) { + super(sender, TYPE); + } + + public MsgSsrFlagSatellites() { + super(TYPE); + } + + public MsgSsrFlagSatellites(SBPMessage msg) throws SBPBinaryException { + super(msg); + assert msg.type == TYPE; + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + stub = parser.getArrayofU8(); + } + + @Override + protected void build(Builder builder) { + builder.putArrayofU8(stub); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("stub", new JSONArray(stub)); + return obj; + } +} diff --git a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagTropoGridPoints.java b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagTropoGridPoints.java new file mode 100644 index 0000000000..d674896966 --- /dev/null +++ b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagTropoGridPoints.java @@ -0,0 +1,58 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.integrity; + +// This file was auto-generated from yaml/swiftnav/sbp/integrity.yaml by generate.py. +// Do not modify by hand! + + +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.gnss.*; +import org.json.JSONArray; +import org.json.JSONObject; + +public class MsgSsrFlagTropoGridPoints extends SBPMessage { + public static final int TYPE = 0x0BC3; + + public int[] stub; + + public MsgSsrFlagTropoGridPoints(int sender) { + super(sender, TYPE); + } + + public MsgSsrFlagTropoGridPoints() { + super(TYPE); + } + + public MsgSsrFlagTropoGridPoints(SBPMessage msg) throws SBPBinaryException { + super(msg); + assert msg.type == TYPE; + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + stub = parser.getArrayofU8(); + } + + @Override + protected void build(Builder builder) { + builder.putArrayofU8(stub); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("stub", new JSONArray(stub)); + return obj; + } +} diff --git a/java/src/com/swiftnav/sbp/navigation/MsgGPSLeapSecond.java b/java/src/com/swiftnav/sbp/navigation/MsgGPSLeapSecond.java new file mode 100644 index 0000000000..eb977005e7 --- /dev/null +++ b/java/src/com/swiftnav/sbp/navigation/MsgGPSLeapSecond.java @@ -0,0 +1,66 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.navigation; + +// This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. +// Do not modify by hand! + + +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPMessage; +import org.json.JSONArray; +import org.json.JSONObject; + +/** + * SBP class for message MSG_GPS_LEAP_SECOND (0x023A). + * + *

You can have MSG_GPS_LEAP_SECOND inherent its fields directly from an inherited SBP object, or + * construct it inline using a dict of its fields. + * + *

Emulates the GPS CNAV message, reserving bytes for future broadcast of the drift model + * parameters. + */ +public class MsgGPSLeapSecond extends SBPMessage { + public static final int TYPE = 0x023A; + + public int[] stub; + + public MsgGPSLeapSecond(int sender) { + super(sender, TYPE); + } + + public MsgGPSLeapSecond() { + super(TYPE); + } + + public MsgGPSLeapSecond(SBPMessage msg) throws SBPBinaryException { + super(msg); + assert msg.type == TYPE; + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + stub = parser.getArrayofU8(); + } + + @Override + protected void build(Builder builder) { + builder.putArrayofU8(stub); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("stub", new JSONArray(stub)); + return obj; + } +} diff --git a/java/src/com/swiftnav/sbp/navigation/MsgItrf.java b/java/src/com/swiftnav/sbp/navigation/MsgItrf.java new file mode 100644 index 0000000000..8f6ea00a85 --- /dev/null +++ b/java/src/com/swiftnav/sbp/navigation/MsgItrf.java @@ -0,0 +1,57 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.navigation; + +// This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. +// Do not modify by hand! + + +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPMessage; +import org.json.JSONArray; +import org.json.JSONObject; + +public class MsgItrf extends SBPMessage { + public static final int TYPE = 0x0244; + + public int[] stub; + + public MsgItrf(int sender) { + super(sender, TYPE); + } + + public MsgItrf() { + super(TYPE); + } + + public MsgItrf(SBPMessage msg) throws SBPBinaryException { + super(msg); + assert msg.type == TYPE; + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + stub = parser.getArrayofU8(); + } + + @Override + protected void build(Builder builder) { + builder.putArrayofU8(stub); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("stub", new JSONArray(stub)); + return obj; + } +} diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrCodePhaseBiasesBounds.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrCodePhaseBiasesBounds.java new file mode 100644 index 0000000000..edefe68eb0 --- /dev/null +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrCodePhaseBiasesBounds.java @@ -0,0 +1,58 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.ssr; + +// This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. +// Do not modify by hand! + + +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.gnss.*; +import org.json.JSONArray; +import org.json.JSONObject; + +public class MsgSsrCodePhaseBiasesBounds extends SBPMessage { + public static final int TYPE = 0x05EC; + + public int[] stub; + + public MsgSsrCodePhaseBiasesBounds(int sender) { + super(sender, TYPE); + } + + public MsgSsrCodePhaseBiasesBounds() { + super(TYPE); + } + + public MsgSsrCodePhaseBiasesBounds(SBPMessage msg) throws SBPBinaryException { + super(msg); + assert msg.type == TYPE; + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + stub = parser.getArrayofU8(); + } + + @Override + protected void build(Builder builder) { + builder.putArrayofU8(stub); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("stub", new JSONArray(stub)); + return obj; + } +} diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrectionBounds.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrectionBounds.java new file mode 100644 index 0000000000..ad673c4160 --- /dev/null +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrectionBounds.java @@ -0,0 +1,58 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.ssr; + +// This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. +// Do not modify by hand! + + +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.gnss.*; +import org.json.JSONArray; +import org.json.JSONObject; + +public class MsgSsrGriddedCorrectionBounds extends SBPMessage { + public static final int TYPE = 0x05FE; + + public int[] stub; + + public MsgSsrGriddedCorrectionBounds(int sender) { + super(sender, TYPE); + } + + public MsgSsrGriddedCorrectionBounds() { + super(TYPE); + } + + public MsgSsrGriddedCorrectionBounds(SBPMessage msg) throws SBPBinaryException { + super(msg); + assert msg.type == TYPE; + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + stub = parser.getArrayofU8(); + } + + @Override + protected void build(Builder builder) { + builder.putArrayofU8(stub); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("stub", new JSONArray(stub)); + return obj; + } +} diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockBounds.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockBounds.java new file mode 100644 index 0000000000..12eeab27a5 --- /dev/null +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockBounds.java @@ -0,0 +1,58 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.ssr; + +// This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. +// Do not modify by hand! + + +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.gnss.*; +import org.json.JSONArray; +import org.json.JSONObject; + +public class MsgSsrOrbitClockBounds extends SBPMessage { + public static final int TYPE = 0x05DE; + + public int[] stub; + + public MsgSsrOrbitClockBounds(int sender) { + super(sender, TYPE); + } + + public MsgSsrOrbitClockBounds() { + super(TYPE); + } + + public MsgSsrOrbitClockBounds(SBPMessage msg) throws SBPBinaryException { + super(msg); + assert msg.type == TYPE; + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + stub = parser.getArrayofU8(); + } + + @Override + protected void build(Builder builder) { + builder.putArrayofU8(stub); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("stub", new JSONArray(stub)); + return obj; + } +} diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockBoundsDegradation.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockBoundsDegradation.java new file mode 100644 index 0000000000..9d4a5f5bbe --- /dev/null +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockBoundsDegradation.java @@ -0,0 +1,58 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.ssr; + +// This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. +// Do not modify by hand! + + +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.gnss.*; +import org.json.JSONArray; +import org.json.JSONObject; + +public class MsgSsrOrbitClockBoundsDegradation extends SBPMessage { + public static final int TYPE = 0x05DF; + + public int[] stub; + + public MsgSsrOrbitClockBoundsDegradation(int sender) { + super(sender, TYPE); + } + + public MsgSsrOrbitClockBoundsDegradation() { + super(TYPE); + } + + public MsgSsrOrbitClockBoundsDegradation(SBPMessage msg) throws SBPBinaryException { + super(msg); + assert msg.type == TYPE; + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + stub = parser.getArrayofU8(); + } + + @Override + protected void build(Builder builder) { + builder.putArrayofU8(stub); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("stub", new JSONArray(stub)); + return obj; + } +} diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrection.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrection.java index 9ac3d52f62..9115fefa77 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrection.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrection.java @@ -16,30 +16,14 @@ import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; +import org.json.JSONArray; import org.json.JSONObject; -/** - * SBP class for message MSG_SSR_STEC_CORRECTION (0x05FB). - * - *

You can have MSG_SSR_STEC_CORRECTION inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. - * - *

The Slant Total Electron Content per space vehicle, given as polynomial approximation for a - * given tile. This should be combined with the MSG_SSR_GRIDDED_CORRECTION message to get the state - * space representation of the atmospheric delay. - * - *

It is typically equivalent to the QZSS CLAS Sub Type 8 messages. - */ public class MsgSsrStecCorrection extends SBPMessage { - public static final int TYPE = 0x05FB; - - /** Header of a STEC polynomial coefficient message. */ - public STECHeader header; + public static final int TYPE = 0x05FD; - /** Array of STEC polynomial coefficients for each space vehicle. */ - public STECSatElement[] stec_sat_list; + public int[] stub; public MsgSsrStecCorrection(int sender) { super(sender, TYPE); @@ -57,21 +41,18 @@ public MsgSsrStecCorrection(SBPMessage msg) throws SBPBinaryException { @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - header = new STECHeader().parse(parser); - stec_sat_list = parser.getArray(STECSatElement.class); + stub = parser.getArrayofU8(); } @Override protected void build(Builder builder) { - header.build(builder); - builder.putArray(stec_sat_list); + builder.putArrayofU8(stub); } @Override public JSONObject toJSON() { JSONObject obj = super.toJSON(); - obj.put("header", header.toJSON()); - obj.put("stec_sat_list", SBPStruct.toJSONArray(stec_sat_list)); + obj.put("stub", new JSONArray(stub)); return obj; } } diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrectionDep.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrectionDep.java new file mode 100644 index 0000000000..db9b661bd4 --- /dev/null +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrectionDep.java @@ -0,0 +1,77 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.ssr; + +// This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. +// Do not modify by hand! + + +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPStruct; +import com.swiftnav.sbp.gnss.*; +import org.json.JSONObject; + +/** + * SBP class for message MSG_SSR_STEC_CORRECTION_DEP (0x05FB). + * + *

You can have MSG_SSR_STEC_CORRECTION_DEP inherent its fields directly from an inherited SBP + * object, or construct it inline using a dict of its fields. + * + *

The Slant Total Electron Content per space vehicle, given as polynomial approximation for a + * given tile. This should be combined with the MSG_SSR_GRIDDED_CORRECTION message to get the state + * space representation of the atmospheric delay. + * + *

It is typically equivalent to the QZSS CLAS Sub Type 8 messages. + */ +public class MsgSsrStecCorrectionDep extends SBPMessage { + public static final int TYPE = 0x05FB; + + /** Header of a STEC polynomial coefficient message. */ + public STECHeader header; + + /** Array of STEC polynomial coefficients for each space vehicle. */ + public STECSatElement[] stec_sat_list; + + public MsgSsrStecCorrectionDep(int sender) { + super(sender, TYPE); + } + + public MsgSsrStecCorrectionDep() { + super(TYPE); + } + + public MsgSsrStecCorrectionDep(SBPMessage msg) throws SBPBinaryException { + super(msg); + assert msg.type == TYPE; + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + header = new STECHeader().parse(parser); + stec_sat_list = parser.getArray(STECSatElement.class); + } + + @Override + protected void build(Builder builder) { + header.build(builder); + builder.putArray(stec_sat_list); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("header", header.toJSON()); + obj.put("stec_sat_list", SBPStruct.toJSONArray(stec_sat_list)); + return obj; + } +} diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinition.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinition.java index 839c2d40a8..96e19bee2a 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinition.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinition.java @@ -17,11 +17,11 @@ import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; import com.swiftnav.sbp.gnss.*; -import java.math.BigInteger; +import org.json.JSONArray; import org.json.JSONObject; /** - * SBP class for message MSG_SSR_TILE_DEFINITION (0x05F6). + * SBP class for message MSG_SSR_TILE_DEFINITION (0x05F7). * *

You can have MSG_SSR_TILE_DEFINITION inherent its fields directly from an inherited SBP * object, or construct it inline using a dict of its fields. @@ -34,82 +34,9 @@ * points. */ public class MsgSsrTileDefinition extends SBPMessage { - public static final int TYPE = 0x05F6; + public static final int TYPE = 0x05F7; - /** Unique identifier of the tile set this tile belongs to. */ - public int tile_set_id; - - /** - * Unique identifier of this tile in the tile set. See GNSS-SSR-ArrayOfCorrectionPoints field - * correctionPointSetID. - */ - public int tile_id; - - /** - * North-West corner correction point latitude. - * - *

The relation between the latitude X in the range [-90, 90] and the coded number N is: - * - *

N = floor((X / 90) * 2^14) - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLatitude. - */ - public int corner_nw_lat; - - /** - * North-West corner correction point longitude. - * - *

The relation between the longitude X in the range [-180, 180] and the coded number N is: - * - *

N = floor((X / 180) * 2^15) - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLongitude. - */ - public int corner_nw_lon; - - /** - * Spacing of the correction points in the latitude direction. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLatitude. - */ - public int spacing_lat; - - /** - * Spacing of the correction points in the longitude direction. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLongitude. - */ - public int spacing_lon; - - /** - * Number of steps in the latitude direction. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLatitude. - */ - public int rows; - - /** - * Number of steps in the longitude direction. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLongitude. - */ - public int cols; - - /** - * Specifies the availability of correction data at the correction points in the array. - * - *

If a specific bit is enabled (set to 1), the correction is not available. Only the first - * rows * cols bits are used, the remainder are set to 0. If there are more then 64 correction - * points the remaining corrections are always available. - * - *

Starting with the northwest corner of the array (top left on a north oriented map) the - * correction points are enumerated with row precedence - first row west to east, second row - * west to east, until last row west to east - ending with the southeast corner of the array. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field bitmaskOfGrids but note the definition of the - * bits is inverted. - */ - public BigInteger bitmask; + public int[] stub; public MsgSsrTileDefinition(int sender) { super(sender, TYPE); @@ -127,42 +54,18 @@ public MsgSsrTileDefinition(SBPMessage msg) throws SBPBinaryException { @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - tile_set_id = parser.getU16(); - tile_id = parser.getU16(); - corner_nw_lat = parser.getS16(); - corner_nw_lon = parser.getS16(); - spacing_lat = parser.getU16(); - spacing_lon = parser.getU16(); - rows = parser.getU16(); - cols = parser.getU16(); - bitmask = parser.getU64(); + stub = parser.getArrayofU8(); } @Override protected void build(Builder builder) { - builder.putU16(tile_set_id); - builder.putU16(tile_id); - builder.putS16(corner_nw_lat); - builder.putS16(corner_nw_lon); - builder.putU16(spacing_lat); - builder.putU16(spacing_lon); - builder.putU16(rows); - builder.putU16(cols); - builder.putU64(bitmask); + builder.putArrayofU8(stub); } @Override public JSONObject toJSON() { JSONObject obj = super.toJSON(); - obj.put("tile_set_id", tile_set_id); - obj.put("tile_id", tile_id); - obj.put("corner_nw_lat", corner_nw_lat); - obj.put("corner_nw_lon", corner_nw_lon); - obj.put("spacing_lat", spacing_lat); - obj.put("spacing_lon", spacing_lon); - obj.put("rows", rows); - obj.put("cols", cols); - obj.put("bitmask", bitmask); + obj.put("stub", new JSONArray(stub)); return obj; } } diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinitionDep.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinitionDep.java new file mode 100644 index 0000000000..0d2c14c5b8 --- /dev/null +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinitionDep.java @@ -0,0 +1,168 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.ssr; + +// This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. +// Do not modify by hand! + + +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.gnss.*; +import java.math.BigInteger; +import org.json.JSONObject; + +/** + * SBP class for message MSG_SSR_TILE_DEFINITION_DEP (0x05F6). + * + *

You can have MSG_SSR_TILE_DEFINITION_DEP inherent its fields directly from an inherited SBP + * object, or construct it inline using a dict of its fields. + * + *

Provides the correction point coordinates for the atmospheric correction values in the + * MSG_SSR_STEC_CORRECTION_DEP and MSG_SSR_GRIDDED_CORRECTION messages. + * + *

Based on ETSI TS 137 355 V16.1.0 (LTE Positioning Protocol) information element + * GNSS-SSR-CorrectionPoints. SBP only supports gridded arrays of correction points, not lists of + * points. + */ +public class MsgSsrTileDefinitionDep extends SBPMessage { + public static final int TYPE = 0x05F6; + + /** Unique identifier of the tile set this tile belongs to. */ + public int tile_set_id; + + /** + * Unique identifier of this tile in the tile set. See GNSS-SSR-ArrayOfCorrectionPoints field + * correctionPointSetID. + */ + public int tile_id; + + /** + * North-West corner correction point latitude. + * + *

The relation between the latitude X in the range [-90, 90] and the coded number N is: + * + *

N = floor((X / 90) * 2^14) + * + *

See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLatitude. + */ + public int corner_nw_lat; + + /** + * North-West corner correction point longitude. + * + *

The relation between the longitude X in the range [-180, 180] and the coded number N is: + * + *

N = floor((X / 180) * 2^15) + * + *

See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLongitude. + */ + public int corner_nw_lon; + + /** + * Spacing of the correction points in the latitude direction. + * + *

See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLatitude. + */ + public int spacing_lat; + + /** + * Spacing of the correction points in the longitude direction. + * + *

See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLongitude. + */ + public int spacing_lon; + + /** + * Number of steps in the latitude direction. + * + *

See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLatitude. + */ + public int rows; + + /** + * Number of steps in the longitude direction. + * + *

See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLongitude. + */ + public int cols; + + /** + * Specifies the availability of correction data at the correction points in the array. + * + *

If a specific bit is enabled (set to 1), the correction is not available. Only the first + * rows * cols bits are used, the remainder are set to 0. If there are more then 64 correction + * points the remaining corrections are always available. + * + *

Starting with the northwest corner of the array (top left on a north oriented map) the + * correction points are enumerated with row precedence - first row west to east, second row + * west to east, until last row west to east - ending with the southeast corner of the array. + * + *

See GNSS-SSR-ArrayOfCorrectionPoints field bitmaskOfGrids but note the definition of the + * bits is inverted. + */ + public BigInteger bitmask; + + public MsgSsrTileDefinitionDep(int sender) { + super(sender, TYPE); + } + + public MsgSsrTileDefinitionDep() { + super(TYPE); + } + + public MsgSsrTileDefinitionDep(SBPMessage msg) throws SBPBinaryException { + super(msg); + assert msg.type == TYPE; + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + tile_set_id = parser.getU16(); + tile_id = parser.getU16(); + corner_nw_lat = parser.getS16(); + corner_nw_lon = parser.getS16(); + spacing_lat = parser.getU16(); + spacing_lon = parser.getU16(); + rows = parser.getU16(); + cols = parser.getU16(); + bitmask = parser.getU64(); + } + + @Override + protected void build(Builder builder) { + builder.putU16(tile_set_id); + builder.putU16(tile_id); + builder.putS16(corner_nw_lat); + builder.putS16(corner_nw_lon); + builder.putU16(spacing_lat); + builder.putU16(spacing_lon); + builder.putU16(rows); + builder.putU16(cols); + builder.putU64(bitmask); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("tile_set_id", tile_set_id); + obj.put("tile_id", tile_id); + obj.put("corner_nw_lat", corner_nw_lat); + obj.put("corner_nw_lon", corner_nw_lon); + obj.put("spacing_lat", spacing_lat); + obj.put("spacing_lon", spacing_lon); + obj.put("rows", rows); + obj.put("cols", cols); + obj.put("bitmask", bitmask); + return obj; + } +} diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java new file mode 100644 index 0000000000..f3f2bad485 --- /dev/null +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java @@ -0,0 +1,358 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.test; + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml by generate.py. Do not +// modify by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.integrity.MsgSsrFlagHighLevel; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_integrity_MsgSsrFlagHighLevelTest { + + public static boolean debug = false; + private static final double DELTA = 1e-15; + + @Test + public void test1() throws Throwable { + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.test1"); + byte[] payload = + new byte[] { + (byte) 180, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 3, + (byte) 0, + (byte) 104, + (byte) 1, + (byte) 0, + (byte) 0, + (byte) 6, + (byte) 0, + (byte) 10, + (byte) 20, + (byte) 0, + (byte) 30, + (byte) 0, + (byte) 40, + (byte) 1, + (byte) 2, + (byte) 3, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 4, + (byte) 5, + (byte) 6, + (byte) 7, + }; + SBPMessage sbp = new SBPMessage(0x0042, 0x0BB9, payload); + MsgSsrFlagHighLevel msg = new MsgSsrFlagHighLevel(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + value = msg.stub[0]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[0] + "' != '" + 180 + "'", + value.equals(BigInteger.valueOf(180L))); + } else { + value = value.longValue(); + expected = 180L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[1]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[1] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[2]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[2] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[3]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[3] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[4]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[4] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[5]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[5] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[6]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[6] + "' != '" + 104 + "'", + value.equals(BigInteger.valueOf(104L))); + } else { + value = value.longValue(); + expected = 104L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[7]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[7] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[8]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[8] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[9]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[9] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[10]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[10] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + } else { + value = value.longValue(); + expected = 6L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[11]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[11] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[12]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[12] + "' != '" + 10 + "'", + value.equals(BigInteger.valueOf(10L))); + } else { + value = value.longValue(); + expected = 10L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[13]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[13] + "' != '" + 20 + "'", + value.equals(BigInteger.valueOf(20L))); + } else { + value = value.longValue(); + expected = 20L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[14]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[14] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[15]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[15] + "' != '" + 30 + "'", + value.equals(BigInteger.valueOf(30L))); + } else { + value = value.longValue(); + expected = 30L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[16]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[16] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[17]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[17] + "' != '" + 40 + "'", + value.equals(BigInteger.valueOf(40L))); + } else { + value = value.longValue(); + expected = 40L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[18]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[18] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[19]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[19] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[20]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[20] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[21]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[21] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[22]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[22] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[23]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[23] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[24]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[24] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[25]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[25] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[26]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[26] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[27]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[27] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + } else { + value = value.longValue(); + expected = 4L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[28]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[28] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + } else { + value = value.longValue(); + expected = 5L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[29]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[29] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + } else { + value = value.longValue(); + expected = 6L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[30]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[30] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf(7L))); + } else { + value = value.longValue(); + expected = 7L; + org.junit.Assert.assertEquals(value, expected); + } + } +} diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLosTest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLosTest.java new file mode 100644 index 0000000000..2aea06b7b2 --- /dev/null +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLosTest.java @@ -0,0 +1,259 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.test; + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPointSatLos.yaml by generate.py. Do +// not modify by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.integrity.MsgSsrFlagIonoGridPointSatLos; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLosTest { + + public static boolean debug = false; + private static final double DELTA = 1e-15; + + @Test + public void test1() throws Throwable { + if (debug) + System.out.format( + "%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLosTest.test1"); + byte[] payload = + new byte[] { + (byte) 180, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 3, + (byte) 0, + (byte) 1, + (byte) 2, + (byte) 3, + (byte) 4, + (byte) 0, + (byte) 5, + (byte) 0, + (byte) 6, + (byte) 30, + (byte) 0, + (byte) 2, + (byte) 10, + (byte) 11, + (byte) 15, + (byte) 14, + }; + SBPMessage sbp = new SBPMessage(0x0042, 0x0BD1, payload); + MsgSsrFlagIonoGridPointSatLos msg = new MsgSsrFlagIonoGridPointSatLos(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + value = msg.stub[0]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[0] + "' != '" + 180 + "'", + value.equals(BigInteger.valueOf(180L))); + } else { + value = value.longValue(); + expected = 180L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[1]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[1] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[2]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[2] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[3]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[3] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[4]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[4] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[5]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[5] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[6]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[6] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[7]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[7] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[8]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[8] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[9]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[9] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + } else { + value = value.longValue(); + expected = 4L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[10]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[10] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[11]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[11] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + } else { + value = value.longValue(); + expected = 5L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[12]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[12] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[13]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[13] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + } else { + value = value.longValue(); + expected = 6L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[14]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[14] + "' != '" + 30 + "'", + value.equals(BigInteger.valueOf(30L))); + } else { + value = value.longValue(); + expected = 30L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[15]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[15] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[16]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[16] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[17]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[17] + "' != '" + 10 + "'", + value.equals(BigInteger.valueOf(10L))); + } else { + value = value.longValue(); + expected = 10L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[18]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[18] + "' != '" + 11 + "'", + value.equals(BigInteger.valueOf(11L))); + } else { + value = value.longValue(); + expected = 11L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[19]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[19] + "' != '" + 15 + "'", + value.equals(BigInteger.valueOf(15L))); + } else { + value = value.longValue(); + expected = 15L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[20]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[20] + "' != '" + 14 + "'", + value.equals(BigInteger.valueOf(14L))); + } else { + value = value.longValue(); + expected = 14L; + org.junit.Assert.assertEquals(value, expected); + } + } +} diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointsTest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointsTest.java new file mode 100644 index 0000000000..5e79c469a1 --- /dev/null +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointsTest.java @@ -0,0 +1,257 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.test; + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPoints.yaml by generate.py. Do not +// modify by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.integrity.MsgSsrFlagIonoGridPoints; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_integrity_MsgSsrFlagIonoGridPointsTest { + + public static boolean debug = false; + private static final double DELTA = 1e-15; + + @Test + public void test1() throws Throwable { + if (debug) + System.out.format( + "%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagIonoGridPointsTest.test1"); + byte[] payload = + new byte[] { + (byte) 180, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 3, + (byte) 0, + (byte) 1, + (byte) 2, + (byte) 3, + (byte) 4, + (byte) 0, + (byte) 5, + (byte) 0, + (byte) 6, + (byte) 3, + (byte) 10, + (byte) 0, + (byte) 11, + (byte) 0, + (byte) 12, + (byte) 0, + }; + SBPMessage sbp = new SBPMessage(0x0042, 0x0BC7, payload); + MsgSsrFlagIonoGridPoints msg = new MsgSsrFlagIonoGridPoints(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + value = msg.stub[0]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[0] + "' != '" + 180 + "'", + value.equals(BigInteger.valueOf(180L))); + } else { + value = value.longValue(); + expected = 180L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[1]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[1] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[2]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[2] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[3]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[3] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[4]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[4] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[5]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[5] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[6]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[6] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[7]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[7] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[8]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[8] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[9]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[9] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + } else { + value = value.longValue(); + expected = 4L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[10]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[10] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[11]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[11] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + } else { + value = value.longValue(); + expected = 5L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[12]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[12] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[13]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[13] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + } else { + value = value.longValue(); + expected = 6L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[14]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[14] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[15]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[15] + "' != '" + 10 + "'", + value.equals(BigInteger.valueOf(10L))); + } else { + value = value.longValue(); + expected = 10L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[16]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[16] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[17]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[17] + "' != '" + 11 + "'", + value.equals(BigInteger.valueOf(11L))); + } else { + value = value.longValue(); + expected = 11L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[18]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[18] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[19]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[19] + "' != '" + 12 + "'", + value.equals(BigInteger.valueOf(12L))); + } else { + value = value.longValue(); + expected = 12L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[20]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[20] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + } +} diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLosTest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLosTest.java new file mode 100644 index 0000000000..2a0fff770d --- /dev/null +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLosTest.java @@ -0,0 +1,238 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.test; + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoTileSatLos.yaml by generate.py. Do not +// modify by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.integrity.MsgSsrFlagIonoTileSatLos; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLosTest { + + public static boolean debug = false; + private static final double DELTA = 1e-15; + + @Test + public void test1() throws Throwable { + if (debug) + System.out.format( + "%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLosTest.test1"); + byte[] payload = + new byte[] { + (byte) 180, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 3, + (byte) 0, + (byte) 1, + (byte) 2, + (byte) 3, + (byte) 4, + (byte) 0, + (byte) 5, + (byte) 0, + (byte) 6, + (byte) 2, + (byte) 10, + (byte) 11, + (byte) 15, + (byte) 14, + }; + SBPMessage sbp = new SBPMessage(0x0042, 0x0BCD, payload); + MsgSsrFlagIonoTileSatLos msg = new MsgSsrFlagIonoTileSatLos(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + value = msg.stub[0]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[0] + "' != '" + 180 + "'", + value.equals(BigInteger.valueOf(180L))); + } else { + value = value.longValue(); + expected = 180L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[1]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[1] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[2]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[2] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[3]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[3] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[4]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[4] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[5]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[5] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[6]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[6] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[7]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[7] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[8]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[8] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[9]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[9] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + } else { + value = value.longValue(); + expected = 4L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[10]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[10] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[11]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[11] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + } else { + value = value.longValue(); + expected = 5L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[12]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[12] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[13]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[13] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + } else { + value = value.longValue(); + expected = 6L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[14]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[14] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[15]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[15] + "' != '" + 10 + "'", + value.equals(BigInteger.valueOf(10L))); + } else { + value = value.longValue(); + expected = 10L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[16]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[16] + "' != '" + 11 + "'", + value.equals(BigInteger.valueOf(11L))); + } else { + value = value.longValue(); + expected = 11L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[17]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[17] + "' != '" + 15 + "'", + value.equals(BigInteger.valueOf(15L))); + } else { + value = value.longValue(); + expected = 15L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[18]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[18] + "' != '" + 14 + "'", + value.equals(BigInteger.valueOf(14L))); + } else { + value = value.longValue(); + expected = 14L; + org.junit.Assert.assertEquals(value, expected); + } + } +} diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagSatellitesTest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagSatellitesTest.java new file mode 100644 index 0000000000..8951d5f763 --- /dev/null +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagSatellitesTest.java @@ -0,0 +1,184 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.test; + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagSatellites.yaml by generate.py. Do not +// modify by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.integrity.MsgSsrFlagSatellites; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_integrity_MsgSsrFlagSatellitesTest { + + public static boolean debug = false; + private static final double DELTA = 1e-15; + + @Test + public void test1() throws Throwable { + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagSatellitesTest.test1"); + byte[] payload = + new byte[] { + (byte) 180, (byte) 0, (byte) 0, (byte) 0, (byte) 3, (byte) 0, (byte) 1, + (byte) 2, (byte) 3, (byte) 4, (byte) 5, (byte) 3, (byte) 10, (byte) 11, + (byte) 12, + }; + SBPMessage sbp = new SBPMessage(0x0042, 0x0BBD, payload); + MsgSsrFlagSatellites msg = new MsgSsrFlagSatellites(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + value = msg.stub[0]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[0] + "' != '" + 180 + "'", + value.equals(BigInteger.valueOf(180L))); + } else { + value = value.longValue(); + expected = 180L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[1]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[1] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[2]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[2] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[3]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[3] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[4]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[4] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[5]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[5] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[6]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[6] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[7]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[7] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[8]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[8] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[9]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[9] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + } else { + value = value.longValue(); + expected = 4L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[10]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[10] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + } else { + value = value.longValue(); + expected = 5L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[11]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[11] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[12]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[12] + "' != '" + 10 + "'", + value.equals(BigInteger.valueOf(10L))); + } else { + value = value.longValue(); + expected = 10L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[13]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[13] + "' != '" + 11 + "'", + value.equals(BigInteger.valueOf(11L))); + } else { + value = value.longValue(); + expected = 11L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[14]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[14] + "' != '" + 12 + "'", + value.equals(BigInteger.valueOf(12L))); + } else { + value = value.longValue(); + expected = 12L; + org.junit.Assert.assertEquals(value, expected); + } + } +} diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagTropoGridPointsTest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagTropoGridPointsTest.java new file mode 100644 index 0000000000..ad34484275 --- /dev/null +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagTropoGridPointsTest.java @@ -0,0 +1,257 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.test; + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagTropoGridPoints.yaml by generate.py. Do not +// modify by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.integrity.MsgSsrFlagTropoGridPoints; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_integrity_MsgSsrFlagTropoGridPointsTest { + + public static boolean debug = false; + private static final double DELTA = 1e-15; + + @Test + public void test1() throws Throwable { + if (debug) + System.out.format( + "%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagTropoGridPointsTest.test1"); + byte[] payload = + new byte[] { + (byte) 180, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 3, + (byte) 0, + (byte) 1, + (byte) 2, + (byte) 3, + (byte) 4, + (byte) 0, + (byte) 5, + (byte) 0, + (byte) 6, + (byte) 3, + (byte) 10, + (byte) 0, + (byte) 11, + (byte) 0, + (byte) 12, + (byte) 0, + }; + SBPMessage sbp = new SBPMessage(0x0042, 0x0BC3, payload); + MsgSsrFlagTropoGridPoints msg = new MsgSsrFlagTropoGridPoints(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + value = msg.stub[0]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[0] + "' != '" + 180 + "'", + value.equals(BigInteger.valueOf(180L))); + } else { + value = value.longValue(); + expected = 180L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[1]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[1] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[2]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[2] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[3]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[3] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[4]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[4] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[5]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[5] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[6]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[6] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[7]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[7] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[8]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[8] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[9]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[9] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + } else { + value = value.longValue(); + expected = 4L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[10]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[10] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[11]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[11] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + } else { + value = value.longValue(); + expected = 5L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[12]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[12] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[13]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[13] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + } else { + value = value.longValue(); + expected = 6L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[14]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[14] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[15]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[15] + "' != '" + 10 + "'", + value.equals(BigInteger.valueOf(10L))); + } else { + value = value.longValue(); + expected = 10L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[16]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[16] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[17]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[17] + "' != '" + 11 + "'", + value.equals(BigInteger.valueOf(11L))); + } else { + value = value.longValue(); + expected = 11L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[18]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[18] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[19]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[19] + "' != '" + 12 + "'", + value.equals(BigInteger.valueOf(12L))); + } else { + value = value.longValue(); + expected = 12L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[20]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[20] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + } +} diff --git a/java/test/auto_check_sbp_navigation_MsgGPSLeapSecondTest.java b/java/test/auto_check_sbp_navigation_MsgGPSLeapSecondTest.java new file mode 100644 index 0000000000..b0b9a7aa68 --- /dev/null +++ b/java/test/auto_check_sbp_navigation_MsgGPSLeapSecondTest.java @@ -0,0 +1,170 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.test; + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSLeapSecond.yaml by generate.py. Do not modify +// by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.navigation.MsgGPSLeapSecond; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_navigation_MsgGPSLeapSecondTest { + + public static boolean debug = false; + private static final double DELTA = 1e-15; + + @Test + public void test1() throws Throwable { + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSLeapSecondTest.test1"); + byte[] payload = + new byte[] { + (byte) 1, (byte) 0, (byte) 2, (byte) 0, (byte) 3, (byte) 4, (byte) 5, (byte) 0, + (byte) 6, (byte) 0, (byte) 7, (byte) 0, (byte) 8, (byte) 9, + }; + SBPMessage sbp = new SBPMessage(0x0042, 0x023A, payload); + MsgGPSLeapSecond msg = new MsgGPSLeapSecond(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + value = msg.stub[0]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[0] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[1]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[1] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[2]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[2] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[3]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[3] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[4]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[4] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[5]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[5] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + } else { + value = value.longValue(); + expected = 4L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[6]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[6] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + } else { + value = value.longValue(); + expected = 5L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[7]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[7] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[8]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[8] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + } else { + value = value.longValue(); + expected = 6L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[9]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[9] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[10]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[10] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf(7L))); + } else { + value = value.longValue(); + expected = 7L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[11]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[11] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[12]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[12] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + } else { + value = value.longValue(); + expected = 8L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[13]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[13] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + } else { + value = value.longValue(); + expected = 9L; + org.junit.Assert.assertEquals(value, expected); + } + } +} diff --git a/java/test/auto_check_sbp_navigation_MsgItrfTest.java b/java/test/auto_check_sbp_navigation_MsgItrfTest.java new file mode 100644 index 0000000000..aa86b83e61 --- /dev/null +++ b/java/test/auto_check_sbp_navigation_MsgItrfTest.java @@ -0,0 +1,1297 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.test; + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml by +// generate.py. Do not modify by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.navigation.MsgItrf; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_navigation_MsgItrfTest { + + public static boolean debug = false; + private static final double DELTA = 1e-15; + + @Test + public void test1() throws Throwable { + if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgItrfTest.test1"); + byte[] payload = + new byte[] { + (byte) 1, + (byte) 2, + (byte) 102, + (byte) 111, + (byte) 111, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 3, + (byte) 98, + (byte) 97, + (byte) 114, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 4, + (byte) 5, + (byte) 0, + (byte) 6, + (byte) 0, + (byte) 7, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 8, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 9, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 10, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 11, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 12, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 13, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 14, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 15, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 16, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 17, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 18, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 19, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 20, + (byte) 0, + }; + SBPMessage sbp = new SBPMessage(0x0042, 0x0244, payload); + MsgItrf msg = new MsgItrf(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + value = msg.stub[0]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[0] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[1]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[1] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[2]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[2] + "' != '" + 102 + "'", + value.equals(BigInteger.valueOf(102L))); + } else { + value = value.longValue(); + expected = 102L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[3]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[3] + "' != '" + 111 + "'", + value.equals(BigInteger.valueOf(111L))); + } else { + value = value.longValue(); + expected = 111L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[4]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[4] + "' != '" + 111 + "'", + value.equals(BigInteger.valueOf(111L))); + } else { + value = value.longValue(); + expected = 111L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[5]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[5] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[6]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[6] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[7]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[7] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[8]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[8] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[9]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[9] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[10]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[10] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[11]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[11] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[12]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[12] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[13]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[13] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[14]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[14] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[15]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[15] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[16]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[16] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[17]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[17] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[18]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[18] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[19]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[19] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[20]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[20] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[21]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[21] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[22]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[22] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[23]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[23] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[24]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[24] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[25]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[25] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[26]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[26] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[27]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[27] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[28]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[28] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[29]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[29] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[30]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[30] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[31]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[31] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[32]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[32] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[33]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[33] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[34]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[34] + "' != '" + 98 + "'", + value.equals(BigInteger.valueOf(98L))); + } else { + value = value.longValue(); + expected = 98L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[35]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[35] + "' != '" + 97 + "'", + value.equals(BigInteger.valueOf(97L))); + } else { + value = value.longValue(); + expected = 97L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[36]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[36] + "' != '" + 114 + "'", + value.equals(BigInteger.valueOf(114L))); + } else { + value = value.longValue(); + expected = 114L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[37]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[37] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[38]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[38] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[39]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[39] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[40]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[40] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[41]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[41] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[42]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[42] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[43]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[43] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[44]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[44] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[45]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[45] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[46]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[46] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[47]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[47] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[48]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[48] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[49]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[49] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[50]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[50] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[51]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[51] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[52]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[52] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[53]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[53] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[54]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[54] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[55]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[55] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[56]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[56] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[57]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[57] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[58]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[58] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[59]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[59] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[60]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[60] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[61]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[61] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[62]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[62] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[63]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[63] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[64]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[64] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[65]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[65] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + } else { + value = value.longValue(); + expected = 4L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[66]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[66] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + } else { + value = value.longValue(); + expected = 5L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[67]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[67] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[68]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[68] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + } else { + value = value.longValue(); + expected = 6L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[69]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[69] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[70]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[70] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf(7L))); + } else { + value = value.longValue(); + expected = 7L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[71]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[71] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[72]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[72] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[73]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[73] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[74]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[74] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + } else { + value = value.longValue(); + expected = 8L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[75]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[75] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[76]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[76] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[77]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[77] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[78]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[78] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + } else { + value = value.longValue(); + expected = 9L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[79]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[79] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[80]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[80] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[81]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[81] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[82]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[82] + "' != '" + 10 + "'", + value.equals(BigInteger.valueOf(10L))); + } else { + value = value.longValue(); + expected = 10L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[83]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[83] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[84]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[84] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[85]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[85] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[86]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[86] + "' != '" + 11 + "'", + value.equals(BigInteger.valueOf(11L))); + } else { + value = value.longValue(); + expected = 11L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[87]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[87] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[88]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[88] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[89]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[89] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[90]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[90] + "' != '" + 12 + "'", + value.equals(BigInteger.valueOf(12L))); + } else { + value = value.longValue(); + expected = 12L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[91]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[91] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[92]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[92] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[93]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[93] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[94]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[94] + "' != '" + 13 + "'", + value.equals(BigInteger.valueOf(13L))); + } else { + value = value.longValue(); + expected = 13L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[95]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[95] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[96]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[96] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[97]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[97] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[98]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[98] + "' != '" + 14 + "'", + value.equals(BigInteger.valueOf(14L))); + } else { + value = value.longValue(); + expected = 14L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[99]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[99] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[100]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[100] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[101]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[101] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[102]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[102] + "' != '" + 15 + "'", + value.equals(BigInteger.valueOf(15L))); + } else { + value = value.longValue(); + expected = 15L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[103]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[103] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[104]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[104] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[105]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[105] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[106]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[106] + "' != '" + 16 + "'", + value.equals(BigInteger.valueOf(16L))); + } else { + value = value.longValue(); + expected = 16L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[107]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[107] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[108]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[108] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[109]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[109] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[110]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[110] + "' != '" + 17 + "'", + value.equals(BigInteger.valueOf(17L))); + } else { + value = value.longValue(); + expected = 17L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[111]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[111] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[112]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[112] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[113]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[113] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[114]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[114] + "' != '" + 18 + "'", + value.equals(BigInteger.valueOf(18L))); + } else { + value = value.longValue(); + expected = 18L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[115]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[115] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[116]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[116] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[117]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[117] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[118]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[118] + "' != '" + 19 + "'", + value.equals(BigInteger.valueOf(19L))); + } else { + value = value.longValue(); + expected = 19L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[119]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[119] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[120]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[120] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[121]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[121] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[122]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[122] + "' != '" + 20 + "'", + value.equals(BigInteger.valueOf(20L))); + } else { + value = value.longValue(); + expected = 20L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[123]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[123] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + } +} diff --git a/java/test/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBoundsTest.java b/java/test/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBoundsTest.java new file mode 100644 index 0000000000..0b4f556ac5 --- /dev/null +++ b/java/test/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBoundsTest.java @@ -0,0 +1,334 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.test; + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrCodePhaseBiasesBounds.yaml by generate.py. Do not +// modify by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.ssr.MsgSsrCodePhaseBiasesBounds; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBoundsTest { + + public static boolean debug = false; + private static final double DELTA = 1e-15; + + @Test + public void test1() throws Throwable { + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBoundsTest.test1"); + byte[] payload = + new byte[] { + (byte) 180, (byte) 0, (byte) 0, (byte) 0, (byte) 3, (byte) 0, (byte) 1, + (byte) 2, (byte) 1, (byte) 14, (byte) 15, (byte) 1, (byte) 3, (byte) 0, + (byte) 3, (byte) 39, (byte) 1, (byte) 39, (byte) 1, (byte) 1, (byte) 3, + (byte) 39, (byte) 1, (byte) 39, (byte) 1, (byte) 1, (byte) 1, (byte) 39, + (byte) 1, (byte) 39, (byte) 1, + }; + SBPMessage sbp = new SBPMessage(0x0042, 0x05EC, payload); + MsgSsrCodePhaseBiasesBounds msg = new MsgSsrCodePhaseBiasesBounds(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + value = msg.stub[0]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[0] + "' != '" + 180 + "'", + value.equals(BigInteger.valueOf(180L))); + } else { + value = value.longValue(); + expected = 180L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[1]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[1] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[2]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[2] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[3]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[3] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[4]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[4] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[5]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[5] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[6]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[6] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[7]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[7] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[8]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[8] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[9]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[9] + "' != '" + 14 + "'", value.equals(BigInteger.valueOf(14L))); + } else { + value = value.longValue(); + expected = 14L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[10]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[10] + "' != '" + 15 + "'", + value.equals(BigInteger.valueOf(15L))); + } else { + value = value.longValue(); + expected = 15L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[11]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[11] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[12]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[12] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[13]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[13] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[14]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[14] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[15]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[15] + "' != '" + 39 + "'", + value.equals(BigInteger.valueOf(39L))); + } else { + value = value.longValue(); + expected = 39L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[16]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[16] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[17]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[17] + "' != '" + 39 + "'", + value.equals(BigInteger.valueOf(39L))); + } else { + value = value.longValue(); + expected = 39L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[18]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[18] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[19]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[19] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[20]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[20] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[21]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[21] + "' != '" + 39 + "'", + value.equals(BigInteger.valueOf(39L))); + } else { + value = value.longValue(); + expected = 39L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[22]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[22] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[23]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[23] + "' != '" + 39 + "'", + value.equals(BigInteger.valueOf(39L))); + } else { + value = value.longValue(); + expected = 39L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[24]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[24] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[25]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[25] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[26]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[26] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[27]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[27] + "' != '" + 39 + "'", + value.equals(BigInteger.valueOf(39L))); + } else { + value = value.longValue(); + expected = 39L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[28]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[28] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[29]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[29] + "' != '" + 39 + "'", + value.equals(BigInteger.valueOf(39L))); + } else { + value = value.longValue(); + expected = 39L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[30]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[30] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + } +} diff --git a/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBoundsTest.java b/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBoundsTest.java new file mode 100644 index 0000000000..cad89c7a18 --- /dev/null +++ b/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBoundsTest.java @@ -0,0 +1,461 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.test; + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrectionBounds.yaml by generate.py. Do not +// modify by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.ssr.MsgSsrGriddedCorrectionBounds; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_ssr_MsgSsrGriddedCorrectionBoundsTest { + + public static boolean debug = false; + private static final double DELTA = 1e-15; + + @Test + public void test1() throws Throwable { + if (debug) + System.out.format( + "%n%s%n", "auto_check_sbp_ssr_MsgSsrGriddedCorrectionBoundsTest.test1"); + byte[] payload = + new byte[] { + (byte) 180, (byte) 0, (byte) 0, (byte) 0, (byte) 3, (byte) 0, (byte) 1, + (byte) 1, (byte) 10, (byte) 0, (byte) 15, (byte) 1, (byte) 0, (byte) 10, + (byte) 0, (byte) 39, (byte) 232, (byte) 3, (byte) 244, (byte) 1, (byte) 100, + (byte) 200, (byte) 150, (byte) 100, (byte) 2, (byte) 5, (byte) 10, (byte) 16, + (byte) 0, (byte) 17, (byte) 18, (byte) 19, (byte) 20, (byte) 21, (byte) 6, + (byte) 10, (byte) 22, (byte) 0, (byte) 23, (byte) 24, (byte) 25, (byte) 26, + (byte) 27, + }; + SBPMessage sbp = new SBPMessage(0x0042, 0x05FE, payload); + MsgSsrGriddedCorrectionBounds msg = new MsgSsrGriddedCorrectionBounds(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + value = msg.stub[0]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[0] + "' != '" + 180 + "'", + value.equals(BigInteger.valueOf(180L))); + } else { + value = value.longValue(); + expected = 180L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[1]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[1] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[2]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[2] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[3]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[3] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[4]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[4] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[5]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[5] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[6]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[6] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[7]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[7] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[8]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[8] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf(10L))); + } else { + value = value.longValue(); + expected = 10L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[9]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[9] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[10]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[10] + "' != '" + 15 + "'", + value.equals(BigInteger.valueOf(15L))); + } else { + value = value.longValue(); + expected = 15L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[11]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[11] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[12]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[12] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[13]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[13] + "' != '" + 10 + "'", + value.equals(BigInteger.valueOf(10L))); + } else { + value = value.longValue(); + expected = 10L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[14]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[14] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[15]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[15] + "' != '" + 39 + "'", + value.equals(BigInteger.valueOf(39L))); + } else { + value = value.longValue(); + expected = 39L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[16]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[16] + "' != '" + 232 + "'", + value.equals(BigInteger.valueOf(232L))); + } else { + value = value.longValue(); + expected = 232L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[17]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[17] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[18]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[18] + "' != '" + 244 + "'", + value.equals(BigInteger.valueOf(244L))); + } else { + value = value.longValue(); + expected = 244L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[19]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[19] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[20]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[20] + "' != '" + 100 + "'", + value.equals(BigInteger.valueOf(100L))); + } else { + value = value.longValue(); + expected = 100L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[21]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[21] + "' != '" + 200 + "'", + value.equals(BigInteger.valueOf(200L))); + } else { + value = value.longValue(); + expected = 200L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[22]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[22] + "' != '" + 150 + "'", + value.equals(BigInteger.valueOf(150L))); + } else { + value = value.longValue(); + expected = 150L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[23]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[23] + "' != '" + 100 + "'", + value.equals(BigInteger.valueOf(100L))); + } else { + value = value.longValue(); + expected = 100L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[24]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[24] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[25]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[25] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + } else { + value = value.longValue(); + expected = 5L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[26]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[26] + "' != '" + 10 + "'", + value.equals(BigInteger.valueOf(10L))); + } else { + value = value.longValue(); + expected = 10L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[27]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[27] + "' != '" + 16 + "'", + value.equals(BigInteger.valueOf(16L))); + } else { + value = value.longValue(); + expected = 16L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[28]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[28] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[29]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[29] + "' != '" + 17 + "'", + value.equals(BigInteger.valueOf(17L))); + } else { + value = value.longValue(); + expected = 17L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[30]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[30] + "' != '" + 18 + "'", + value.equals(BigInteger.valueOf(18L))); + } else { + value = value.longValue(); + expected = 18L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[31]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[31] + "' != '" + 19 + "'", + value.equals(BigInteger.valueOf(19L))); + } else { + value = value.longValue(); + expected = 19L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[32]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[32] + "' != '" + 20 + "'", + value.equals(BigInteger.valueOf(20L))); + } else { + value = value.longValue(); + expected = 20L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[33]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[33] + "' != '" + 21 + "'", + value.equals(BigInteger.valueOf(21L))); + } else { + value = value.longValue(); + expected = 21L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[34]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[34] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + } else { + value = value.longValue(); + expected = 6L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[35]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[35] + "' != '" + 10 + "'", + value.equals(BigInteger.valueOf(10L))); + } else { + value = value.longValue(); + expected = 10L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[36]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[36] + "' != '" + 22 + "'", + value.equals(BigInteger.valueOf(22L))); + } else { + value = value.longValue(); + expected = 22L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[37]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[37] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[38]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[38] + "' != '" + 23 + "'", + value.equals(BigInteger.valueOf(23L))); + } else { + value = value.longValue(); + expected = 23L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[39]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[39] + "' != '" + 24 + "'", + value.equals(BigInteger.valueOf(24L))); + } else { + value = value.longValue(); + expected = 24L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[40]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[40] + "' != '" + 25 + "'", + value.equals(BigInteger.valueOf(25L))); + } else { + value = value.longValue(); + expected = 25L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[41]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[41] + "' != '" + 26 + "'", + value.equals(BigInteger.valueOf(26L))); + } else { + value = value.longValue(); + expected = 26L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[42]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[42] + "' != '" + 27 + "'", + value.equals(BigInteger.valueOf(27L))); + } else { + value = value.longValue(); + expected = 27L; + org.junit.Assert.assertEquals(value, expected); + } + } +} diff --git a/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradationTest.java b/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradationTest.java new file mode 100644 index 0000000000..1b3402cf41 --- /dev/null +++ b/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradationTest.java @@ -0,0 +1,334 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.test; + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBoundsDegradation.yaml by generate.py. Do +// not modify by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.ssr.MsgSsrOrbitClockBoundsDegradation; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradationTest { + + public static boolean debug = false; + private static final double DELTA = 1e-15; + + @Test + public void test1() throws Throwable { + if (debug) + System.out.format( + "%n%s%n", "auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradationTest.test1"); + byte[] payload = + new byte[] { + (byte) 180, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 3, + (byte) 0, + (byte) 1, + (byte) 2, + (byte) 3, + (byte) 48, + (byte) 15, + (byte) 1, + (byte) 10, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 200, + (byte) 199, + (byte) 198, + (byte) 197, + (byte) 196, + (byte) 195, + (byte) 194, + (byte) 193, + }; + SBPMessage sbp = new SBPMessage(0x0042, 0x05DF, payload); + MsgSsrOrbitClockBoundsDegradation msg = new MsgSsrOrbitClockBoundsDegradation(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + value = msg.stub[0]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[0] + "' != '" + 180 + "'", + value.equals(BigInteger.valueOf(180L))); + } else { + value = value.longValue(); + expected = 180L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[1]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[1] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[2]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[2] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[3]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[3] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[4]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[4] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[5]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[5] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[6]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[6] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[7]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[7] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[8]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[8] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[9]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[9] + "' != '" + 48 + "'", value.equals(BigInteger.valueOf(48L))); + } else { + value = value.longValue(); + expected = 48L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[10]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[10] + "' != '" + 15 + "'", + value.equals(BigInteger.valueOf(15L))); + } else { + value = value.longValue(); + expected = 15L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[11]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[11] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[12]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[12] + "' != '" + 10 + "'", + value.equals(BigInteger.valueOf(10L))); + } else { + value = value.longValue(); + expected = 10L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[13]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[13] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[14]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[14] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[15]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[15] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[16]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[16] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[17]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[17] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[18]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[18] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[19]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[19] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[20]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[20] + "' != '" + 200 + "'", + value.equals(BigInteger.valueOf(200L))); + } else { + value = value.longValue(); + expected = 200L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[21]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[21] + "' != '" + 199 + "'", + value.equals(BigInteger.valueOf(199L))); + } else { + value = value.longValue(); + expected = 199L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[22]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[22] + "' != '" + 198 + "'", + value.equals(BigInteger.valueOf(198L))); + } else { + value = value.longValue(); + expected = 198L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[23]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[23] + "' != '" + 197 + "'", + value.equals(BigInteger.valueOf(197L))); + } else { + value = value.longValue(); + expected = 197L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[24]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[24] + "' != '" + 196 + "'", + value.equals(BigInteger.valueOf(196L))); + } else { + value = value.longValue(); + expected = 196L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[25]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[25] + "' != '" + 195 + "'", + value.equals(BigInteger.valueOf(195L))); + } else { + value = value.longValue(); + expected = 195L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[26]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[26] + "' != '" + 194 + "'", + value.equals(BigInteger.valueOf(194L))); + } else { + value = value.longValue(); + expected = 194L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[27]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[27] + "' != '" + 193 + "'", + value.equals(BigInteger.valueOf(193L))); + } else { + value = value.longValue(); + expected = 193L; + org.junit.Assert.assertEquals(value, expected); + } + } +} diff --git a/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsTest.java b/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsTest.java new file mode 100644 index 0000000000..bc916e0b79 --- /dev/null +++ b/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsTest.java @@ -0,0 +1,337 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.test; + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBounds.yaml by generate.py. Do not modify +// by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.ssr.MsgSsrOrbitClockBounds; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_ssr_MsgSsrOrbitClockBoundsTest { + + public static boolean debug = false; + private static final double DELTA = 1e-15; + + @Test + public void test1() throws Throwable { + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrOrbitClockBoundsTest.test1"); + byte[] payload = + new byte[] { + (byte) 180, (byte) 0, (byte) 0, (byte) 0, (byte) 3, (byte) 0, (byte) 1, + (byte) 2, (byte) 3, (byte) 48, (byte) 15, (byte) 1, (byte) 2, (byte) 24, + (byte) 39, (byte) 38, (byte) 37, (byte) 1, (byte) 2, (byte) 3, (byte) 39, + (byte) 1, (byte) 3, (byte) 39, (byte) 38, (byte) 37, (byte) 1, (byte) 2, + (byte) 3, (byte) 39, (byte) 1, + }; + SBPMessage sbp = new SBPMessage(0x0042, 0x05DE, payload); + MsgSsrOrbitClockBounds msg = new MsgSsrOrbitClockBounds(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + value = msg.stub[0]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[0] + "' != '" + 180 + "'", + value.equals(BigInteger.valueOf(180L))); + } else { + value = value.longValue(); + expected = 180L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[1]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[1] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[2]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[2] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[3]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[3] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[4]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[4] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[5]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[5] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[6]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[6] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[7]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[7] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[8]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[8] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[9]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[9] + "' != '" + 48 + "'", value.equals(BigInteger.valueOf(48L))); + } else { + value = value.longValue(); + expected = 48L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[10]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[10] + "' != '" + 15 + "'", + value.equals(BigInteger.valueOf(15L))); + } else { + value = value.longValue(); + expected = 15L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[11]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[11] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[12]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[12] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[13]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[13] + "' != '" + 24 + "'", + value.equals(BigInteger.valueOf(24L))); + } else { + value = value.longValue(); + expected = 24L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[14]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[14] + "' != '" + 39 + "'", + value.equals(BigInteger.valueOf(39L))); + } else { + value = value.longValue(); + expected = 39L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[15]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[15] + "' != '" + 38 + "'", + value.equals(BigInteger.valueOf(38L))); + } else { + value = value.longValue(); + expected = 38L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[16]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[16] + "' != '" + 37 + "'", + value.equals(BigInteger.valueOf(37L))); + } else { + value = value.longValue(); + expected = 37L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[17]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[17] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[18]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[18] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[19]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[19] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[20]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[20] + "' != '" + 39 + "'", + value.equals(BigInteger.valueOf(39L))); + } else { + value = value.longValue(); + expected = 39L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[21]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[21] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[22]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[22] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[23]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[23] + "' != '" + 39 + "'", + value.equals(BigInteger.valueOf(39L))); + } else { + value = value.longValue(); + expected = 39L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[24]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[24] + "' != '" + 38 + "'", + value.equals(BigInteger.valueOf(38L))); + } else { + value = value.longValue(); + expected = 38L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[25]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[25] + "' != '" + 37 + "'", + value.equals(BigInteger.valueOf(37L))); + } else { + value = value.longValue(); + expected = 37L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[26]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[26] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[27]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[27] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[28]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[28] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[29]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[29] + "' != '" + 39 + "'", + value.equals(BigInteger.valueOf(39L))); + } else { + value = value.longValue(); + expected = 39L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[30]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[30] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + } +} diff --git a/java/test/auto_check_sbp_ssr_MsgSsrStecCorrectionTest.java b/java/test/auto_check_sbp_ssr_MsgSsrStecCorrectionTest.java new file mode 100644 index 0000000000..b0c68267c1 --- /dev/null +++ b/java/test/auto_check_sbp_ssr_MsgSsrStecCorrectionTest.java @@ -0,0 +1,401 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.test; + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrStecCorrection.yaml +// by generate.py. Do not modify by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.ssr.MsgSsrStecCorrection; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_ssr_MsgSsrStecCorrectionTest { + + public static boolean debug = false; + private static final double DELTA = 1e-15; + + @Test + public void test1() throws Throwable { + if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrStecCorrectionTest.test1"); + byte[] payload = + new byte[] { + (byte) 180, (byte) 0, (byte) 0, (byte) 0, (byte) 3, (byte) 0, (byte) 1, + (byte) 1, (byte) 10, (byte) 0, (byte) 15, (byte) 1, (byte) 0, (byte) 10, + (byte) 0, (byte) 2, (byte) 1, (byte) 1, (byte) 1, (byte) 63, (byte) 0, + (byte) 62, (byte) 0, (byte) 61, (byte) 0, (byte) 60, (byte) 0, (byte) 31, + (byte) 15, (byte) 5, (byte) 63, (byte) 0, (byte) 64, (byte) 0, (byte) 65, + (byte) 0, (byte) 66, (byte) 0, + }; + SBPMessage sbp = new SBPMessage(0x0042, 0x05FD, payload); + MsgSsrStecCorrection msg = new MsgSsrStecCorrection(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + value = msg.stub[0]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[0] + "' != '" + 180 + "'", + value.equals(BigInteger.valueOf(180L))); + } else { + value = value.longValue(); + expected = 180L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[1]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[1] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[2]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[2] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[3]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[3] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[4]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[4] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[5]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[5] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[6]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[6] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[7]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[7] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[8]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[8] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf(10L))); + } else { + value = value.longValue(); + expected = 10L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[9]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[9] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[10]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[10] + "' != '" + 15 + "'", + value.equals(BigInteger.valueOf(15L))); + } else { + value = value.longValue(); + expected = 15L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[11]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[11] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[12]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[12] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[13]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[13] + "' != '" + 10 + "'", + value.equals(BigInteger.valueOf(10L))); + } else { + value = value.longValue(); + expected = 10L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[14]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[14] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[15]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[15] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[16]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[16] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[17]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[17] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[18]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[18] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[19]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[19] + "' != '" + 63 + "'", + value.equals(BigInteger.valueOf(63L))); + } else { + value = value.longValue(); + expected = 63L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[20]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[20] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[21]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[21] + "' != '" + 62 + "'", + value.equals(BigInteger.valueOf(62L))); + } else { + value = value.longValue(); + expected = 62L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[22]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[22] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[23]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[23] + "' != '" + 61 + "'", + value.equals(BigInteger.valueOf(61L))); + } else { + value = value.longValue(); + expected = 61L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[24]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[24] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[25]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[25] + "' != '" + 60 + "'", + value.equals(BigInteger.valueOf(60L))); + } else { + value = value.longValue(); + expected = 60L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[26]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[26] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[27]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[27] + "' != '" + 31 + "'", + value.equals(BigInteger.valueOf(31L))); + } else { + value = value.longValue(); + expected = 31L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[28]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[28] + "' != '" + 15 + "'", + value.equals(BigInteger.valueOf(15L))); + } else { + value = value.longValue(); + expected = 15L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[29]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[29] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + } else { + value = value.longValue(); + expected = 5L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[30]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[30] + "' != '" + 63 + "'", + value.equals(BigInteger.valueOf(63L))); + } else { + value = value.longValue(); + expected = 63L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[31]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[31] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[32]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[32] + "' != '" + 64 + "'", + value.equals(BigInteger.valueOf(64L))); + } else { + value = value.longValue(); + expected = 64L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[33]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[33] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[34]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[34] + "' != '" + 65 + "'", + value.equals(BigInteger.valueOf(65L))); + } else { + value = value.longValue(); + expected = 65L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[35]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[35] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[36]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[36] + "' != '" + 66 + "'", + value.equals(BigInteger.valueOf(66L))); + } else { + value = value.longValue(); + expected = 66L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[37]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[37] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + } +} diff --git a/java/test/auto_check_sbp_ssr_MsgSsrTileDefinitionTest.java b/java/test/auto_check_sbp_ssr_MsgSsrTileDefinitionTest.java new file mode 100644 index 0000000000..ccfdd439bf --- /dev/null +++ b/java/test/auto_check_sbp_ssr_MsgSsrTileDefinitionTest.java @@ -0,0 +1,297 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.test; + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrTileDefinition.yaml +// by generate.py. Do not modify by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.ssr.MsgSsrTileDefinition; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_ssr_MsgSsrTileDefinitionTest { + + public static boolean debug = false; + private static final double DELTA = 1e-15; + + @Test + public void test1() throws Throwable { + if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrTileDefinitionTest.test1"); + byte[] payload = + new byte[] { + (byte) 31, + (byte) 0, + (byte) 1, + (byte) 0, + (byte) 2, + (byte) 0, + (byte) 4, + (byte) 0, + (byte) 8, + (byte) 0, + (byte) 16, + (byte) 0, + (byte) 32, + (byte) 0, + (byte) 64, + (byte) 0, + (byte) 128, + (byte) 210, + (byte) 2, + (byte) 150, + (byte) 73, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + }; + SBPMessage sbp = new SBPMessage(0x0042, 0x05F7, payload); + MsgSsrTileDefinition msg = new MsgSsrTileDefinition(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + value = msg.stub[0]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[0] + "' != '" + 31 + "'", value.equals(BigInteger.valueOf(31L))); + } else { + value = value.longValue(); + expected = 31L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[1]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[1] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[2]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[2] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[3]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[3] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[4]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[4] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[5]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[5] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[6]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[6] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + } else { + value = value.longValue(); + expected = 4L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[7]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[7] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[8]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[8] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + } else { + value = value.longValue(); + expected = 8L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[9]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[9] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[10]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[10] + "' != '" + 16 + "'", + value.equals(BigInteger.valueOf(16L))); + } else { + value = value.longValue(); + expected = 16L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[11]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[11] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[12]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[12] + "' != '" + 32 + "'", + value.equals(BigInteger.valueOf(32L))); + } else { + value = value.longValue(); + expected = 32L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[13]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[13] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[14]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[14] + "' != '" + 64 + "'", + value.equals(BigInteger.valueOf(64L))); + } else { + value = value.longValue(); + expected = 64L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[15]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[15] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[16]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[16] + "' != '" + 128 + "'", + value.equals(BigInteger.valueOf(128L))); + } else { + value = value.longValue(); + expected = 128L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[17]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[17] + "' != '" + 210 + "'", + value.equals(BigInteger.valueOf(210L))); + } else { + value = value.longValue(); + expected = 210L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[18]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[18] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[19]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[19] + "' != '" + 150 + "'", + value.equals(BigInteger.valueOf(150L))); + } else { + value = value.longValue(); + expected = 150L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[20]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[20] + "' != '" + 73 + "'", + value.equals(BigInteger.valueOf(73L))); + } else { + value = value.longValue(); + expected = 73L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[21]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[21] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[22]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[22] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[23]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[23] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.stub[24]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.stub[24] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + } +} diff --git a/javascript/sbp.bundle.js b/javascript/sbp.bundle.js index 94ad895cd5..c3358c734f 100644 --- a/javascript/sbp.bundle.js +++ b/javascript/sbp.bundle.js @@ -5,11 +5,11 @@ * @author Feross Aboukhadijeh * @license MIT */ -var p=r(25),o=r(26),i=r(16);function s(){return a.TYPED_ARRAY_SUPPORT?2147483647:1073741823}function n(e,t){if(s()=s())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+s().toString(16)+" bytes");return 0|e}function f(e,t){if(a.isBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var r=e.length;if(0===r)return 0;for(var p=!1;;)switch(t){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":case void 0:return F(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return B(e).length;default:if(p)return F(e).length;t=(""+t).toLowerCase(),p=!0}}function d(e,t,r){var p=!1;if((void 0===t||t<0)&&(t=0),t>this.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if((r>>>=0)<=(t>>>=0))return"";for(e||(e="utf8");;)switch(e){case"hex":return D(this,t,r);case"utf8":case"utf-8":return T(this,t,r);case"ascii":return U(this,t,r);case"latin1":case"binary":return M(this,t,r);case"base64":return I(this,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return O(this,t,r);default:if(p)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),p=!0}}function _(e,t,r){var p=e[t];e[t]=e[r],e[r]=p}function S(e,t,r,p,o){if(0===e.length)return-1;if("string"==typeof r?(p=r,r=0):r>2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),r=+r,isNaN(r)&&(r=o?0:e.length-1),r<0&&(r=e.length+r),r>=e.length){if(o)return-1;r=e.length-1}else if(r<0){if(!o)return-1;r=0}if("string"==typeof t&&(t=a.from(t,p)),a.isBuffer(t))return 0===t.length?-1:g(e,t,r,p,o);if("number"==typeof t)return t&=255,a.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?o?Uint8Array.prototype.indexOf.call(e,t,r):Uint8Array.prototype.lastIndexOf.call(e,t,r):g(e,[t],r,p,o);throw new TypeError("val must be string, number or Buffer")}function g(e,t,r,p,o){var i,s=1,n=e.length,a=t.length;if(void 0!==p&&("ucs2"===(p=String(p).toLowerCase())||"ucs-2"===p||"utf16le"===p||"utf-16le"===p)){if(e.length<2||t.length<2)return-1;s=2,n/=2,a/=2,r/=2}function l(e,t){return 1===s?e[t]:e.readUInt16BE(t*s)}if(o){var c=-1;for(i=r;in&&(r=n-a),i=r;i>=0;i--){for(var u=!0,y=0;yo&&(p=o):p=o;var i=t.length;if(i%2!=0)throw new TypeError("Invalid hex string");p>i/2&&(p=i/2);for(var s=0;s>8,o=r%256,i.push(o),i.push(p);return i}(t,e.length-r),e,r,p)}function I(e,t,r){return 0===t&&r===e.length?p.fromByteArray(e):p.fromByteArray(e.slice(t,r))}function T(e,t,r){r=Math.min(e.length,r);for(var p=[],o=t;o239?4:l>223?3:l>191?2:1;if(o+u<=r)switch(u){case 1:l<128&&(c=l);break;case 2:128==(192&(i=e[o+1]))&&(a=(31&l)<<6|63&i)>127&&(c=a);break;case 3:i=e[o+1],s=e[o+2],128==(192&i)&&128==(192&s)&&(a=(15&l)<<12|(63&i)<<6|63&s)>2047&&(a<55296||a>57343)&&(c=a);break;case 4:i=e[o+1],s=e[o+2],n=e[o+3],128==(192&i)&&128==(192&s)&&128==(192&n)&&(a=(15&l)<<18|(63&i)<<12|(63&s)<<6|63&n)>65535&&a<1114112&&(c=a)}null===c?(c=65533,u=1):c>65535&&(c-=65536,p.push(c>>>10&1023|55296),c=56320|1023&c),p.push(c),o+=u}return function(e){var t=e.length;if(t<=4096)return String.fromCharCode.apply(String,e);var r="",p=0;for(;p0&&(e=this.toString("hex",0,r).match(/.{2}/g).join(" "),this.length>r&&(e+=" ... ")),""},a.prototype.compare=function(e,t,r,p,o){if(!a.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===r&&(r=e?e.length:0),void 0===p&&(p=0),void 0===o&&(o=this.length),t<0||r>e.length||p<0||o>this.length)throw new RangeError("out of range index");if(p>=o&&t>=r)return 0;if(p>=o)return-1;if(t>=r)return 1;if(this===e)return 0;for(var i=(o>>>=0)-(p>>>=0),s=(r>>>=0)-(t>>>=0),n=Math.min(i,s),l=this.slice(p,o),c=e.slice(t,r),u=0;uo)&&(r=o),e.length>0&&(r<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");p||(p="utf8");for(var i=!1;;)switch(p){case"hex":return w(this,e,t,r);case"utf8":case"utf-8":return E(this,e,t,r);case"ascii":return m(this,e,t,r);case"latin1":case"binary":return b(this,e,t,r);case"base64":return v(this,e,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return L(this,e,t,r);default:if(i)throw new TypeError("Unknown encoding: "+p);p=(""+p).toLowerCase(),i=!0}},a.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};function U(e,t,r){var p="";r=Math.min(e.length,r);for(var o=t;op)&&(r=p);for(var o="",i=t;ir)throw new RangeError("Trying to access beyond buffer length")}function A(e,t,r,p,o,i){if(!a.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>o||te.length)throw new RangeError("Index out of range")}function C(e,t,r,p){t<0&&(t=65535+t+1);for(var o=0,i=Math.min(e.length-r,2);o>>8*(p?o:1-o)}function R(e,t,r,p){t<0&&(t=4294967295+t+1);for(var o=0,i=Math.min(e.length-r,4);o>>8*(p?o:3-o)&255}function P(e,t,r,p,o,i){if(r+p>e.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function N(e,t,r,p,i){return i||P(e,0,r,4),o.write(e,t,r,p,23,4),r+4}function j(e,t,r,p,i){return i||P(e,0,r,8),o.write(e,t,r,p,52,8),r+8}a.prototype.slice=function(e,t){var r,p=this.length;if((e=~~e)<0?(e+=p)<0&&(e=0):e>p&&(e=p),(t=void 0===t?p:~~t)<0?(t+=p)<0&&(t=0):t>p&&(t=p),t0&&(o*=256);)p+=this[e+--t]*o;return p},a.prototype.readUInt8=function(e,t){return t||G(e,1,this.length),this[e]},a.prototype.readUInt16LE=function(e,t){return t||G(e,2,this.length),this[e]|this[e+1]<<8},a.prototype.readUInt16BE=function(e,t){return t||G(e,2,this.length),this[e]<<8|this[e+1]},a.prototype.readUInt32LE=function(e,t){return t||G(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},a.prototype.readUInt32BE=function(e,t){return t||G(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},a.prototype.readIntLE=function(e,t,r){e|=0,t|=0,r||G(e,t,this.length);for(var p=this[e],o=1,i=0;++i=(o*=128)&&(p-=Math.pow(2,8*t)),p},a.prototype.readIntBE=function(e,t,r){e|=0,t|=0,r||G(e,t,this.length);for(var p=t,o=1,i=this[e+--p];p>0&&(o*=256);)i+=this[e+--p]*o;return i>=(o*=128)&&(i-=Math.pow(2,8*t)),i},a.prototype.readInt8=function(e,t){return t||G(e,1,this.length),128&this[e]?-1*(255-this[e]+1):this[e]},a.prototype.readInt16LE=function(e,t){t||G(e,2,this.length);var r=this[e]|this[e+1]<<8;return 32768&r?4294901760|r:r},a.prototype.readInt16BE=function(e,t){t||G(e,2,this.length);var r=this[e+1]|this[e]<<8;return 32768&r?4294901760|r:r},a.prototype.readInt32LE=function(e,t){return t||G(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},a.prototype.readInt32BE=function(e,t){return t||G(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},a.prototype.readFloatLE=function(e,t){return t||G(e,4,this.length),o.read(this,e,!0,23,4)},a.prototype.readFloatBE=function(e,t){return t||G(e,4,this.length),o.read(this,e,!1,23,4)},a.prototype.readDoubleLE=function(e,t){return t||G(e,8,this.length),o.read(this,e,!0,52,8)},a.prototype.readDoubleBE=function(e,t){return t||G(e,8,this.length),o.read(this,e,!1,52,8)},a.prototype.writeUIntLE=function(e,t,r,p){(e=+e,t|=0,r|=0,p)||A(this,e,t,r,Math.pow(2,8*r)-1,0);var o=1,i=0;for(this[t]=255&e;++i=0&&(i*=256);)this[t+o]=e/i&255;return t+r},a.prototype.writeUInt8=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,1,255,0),a.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),this[t]=255&e,t+1},a.prototype.writeUInt16LE=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,2,65535,0),a.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):C(this,e,t,!0),t+2},a.prototype.writeUInt16BE=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,2,65535,0),a.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):C(this,e,t,!1),t+2},a.prototype.writeUInt32LE=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,4,4294967295,0),a.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):R(this,e,t,!0),t+4},a.prototype.writeUInt32BE=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,4,4294967295,0),a.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):R(this,e,t,!1),t+4},a.prototype.writeIntLE=function(e,t,r,p){if(e=+e,t|=0,!p){var o=Math.pow(2,8*r-1);A(this,e,t,r,o-1,-o)}var i=0,s=1,n=0;for(this[t]=255&e;++i>0)-n&255;return t+r},a.prototype.writeIntBE=function(e,t,r,p){if(e=+e,t|=0,!p){var o=Math.pow(2,8*r-1);A(this,e,t,r,o-1,-o)}var i=r-1,s=1,n=0;for(this[t+i]=255&e;--i>=0&&(s*=256);)e<0&&0===n&&0!==this[t+i+1]&&(n=1),this[t+i]=(e/s>>0)-n&255;return t+r},a.prototype.writeInt8=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,1,127,-128),a.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},a.prototype.writeInt16LE=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,2,32767,-32768),a.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):C(this,e,t,!0),t+2},a.prototype.writeInt16BE=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,2,32767,-32768),a.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):C(this,e,t,!1),t+2},a.prototype.writeInt32LE=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,4,2147483647,-2147483648),a.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):R(this,e,t,!0),t+4},a.prototype.writeInt32BE=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),a.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):R(this,e,t,!1),t+4},a.prototype.writeFloatLE=function(e,t,r){return N(this,e,t,!0,r)},a.prototype.writeFloatBE=function(e,t,r){return N(this,e,t,!1,r)},a.prototype.writeDoubleLE=function(e,t,r){return j(this,e,t,!0,r)},a.prototype.writeDoubleBE=function(e,t,r){return j(this,e,t,!1,r)},a.prototype.copy=function(e,t,r,p){if(r||(r=0),p||0===p||(p=this.length),t>=e.length&&(t=e.length),t||(t=0),p>0&&p=this.length)throw new RangeError("sourceStart out of bounds");if(p<0)throw new RangeError("sourceEnd out of bounds");p>this.length&&(p=this.length),e.length-t=0;--o)e[o+t]=this[o+r];else if(i<1e3||!a.TYPED_ARRAY_SUPPORT)for(o=0;o>>=0,r=void 0===r?this.length:r>>>0,e||(e=0),"number"==typeof e)for(i=t;i55295&&r<57344){if(!o){if(r>56319){(t-=3)>-1&&i.push(239,191,189);continue}if(s+1===p){(t-=3)>-1&&i.push(239,191,189);continue}o=r;continue}if(r<56320){(t-=3)>-1&&i.push(239,191,189),o=r;continue}r=65536+(o-55296<<10|r-56320)}else o&&(t-=3)>-1&&i.push(239,191,189);if(o=null,r<128){if((t-=1)<0)break;i.push(r)}else if(r<2048){if((t-=2)<0)break;i.push(r>>6|192,63&r|128)}else if(r<65536){if((t-=3)<0)break;i.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;i.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return i}function B(e){return p.toByteArray(function(e){if((e=function(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}(e).replace(x,"")).length<2)return"";for(;e.length%4!=0;)e+="=";return e}(e))}function q(e,t,r,p){for(var o=0;o=t.length||o>=e.length);++o)t[o+r]=e[o];return o}}).call(this,r(5))},function(e,t){var r,p,o=e.exports={};function i(){throw new Error("setTimeout has not been defined")}function s(){throw new Error("clearTimeout has not been defined")}function n(e){if(r===setTimeout)return setTimeout(e,0);if((r===i||!r)&&setTimeout)return r=setTimeout,setTimeout(e,0);try{return r(e,0)}catch(t){try{return r.call(null,e,0)}catch(t){return r.call(this,e,0)}}}!function(){try{r="function"==typeof setTimeout?setTimeout:i}catch(e){r=i}try{p="function"==typeof clearTimeout?clearTimeout:s}catch(e){p=s}}();var a,l=[],c=!1,u=-1;function y(){c&&a&&(c=!1,a.length?l=a.concat(l):u=-1,l.length&&h())}function h(){if(!c){var e=n(y);c=!0;for(var t=l.length;t;){for(a=l,l=[];++u1)for(var r=1;r0&&this._events[e].length>s&&(this._events[e].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[e].length),"function"==typeof console.trace&&console.trace()),this},r.prototype.on=r.prototype.addListener,r.prototype.once=function(e,t){if(!p(t))throw TypeError("listener must be a function");var r=!1;function o(){this.removeListener(e,o),r||(r=!0,t.apply(this,arguments))}return o.listener=t,this.on(e,o),this},r.prototype.removeListener=function(e,t){var r,i,s,n;if(!p(t))throw TypeError("listener must be a function");if(!this._events||!this._events[e])return this;if(s=(r=this._events[e]).length,i=-1,r===t||p(r.listener)&&r.listener===t)delete this._events[e],this._events.removeListener&&this.emit("removeListener",e,t);else if(o(r)){for(n=s;n-- >0;)if(r[n]===t||r[n].listener&&r[n].listener===t){i=n;break}if(i<0)return this;1===r.length?(r.length=0,delete this._events[e]):r.splice(i,1),this._events.removeListener&&this.emit("removeListener",e,t)}return this},r.prototype.removeAllListeners=function(e){var t,r;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[e]&&delete this._events[e],this;if(0===arguments.length){for(t in this._events)"removeListener"!==t&&this.removeAllListeners(t);return this.removeAllListeners("removeListener"),this._events={},this}if(p(r=this._events[e]))this.removeListener(e,r);else if(r)for(;r.length;)this.removeListener(e,r[r.length-1]);return delete this._events[e],this},r.prototype.listeners=function(e){return this._events&&this._events[e]?p(this._events[e])?[this._events[e]]:this._events[e].slice():[]},r.prototype.listenerCount=function(e){if(this._events){var t=this._events[e];if(p(t))return 1;if(t)return t.length}return 0},r.listenerCount=function(e,t){return e.listenerCount(t)}},function(e,t,r){(t=e.exports=r(19)).Stream=t,t.Readable=t,t.Writable=r(15),t.Duplex=r(7),t.Transform=r(23),t.PassThrough=r(38)},function(e,t,r){"use strict";(function(t,p,o){var i=r(11);function s(e){var t=this;this.next=null,this.entry=null,this.finish=function(){!function(e,t,r){var p=e.entry;e.entry=null;for(;p;){var o=p.callback;t.pendingcb--,o(r),p=p.next}t.corkedRequestsFree?t.corkedRequestsFree.next=e:t.corkedRequestsFree=e}(t,e)}}e.exports=g;var n,a=!t.browser&&["v0.10","v0.9."].indexOf(t.version.slice(0,5))>-1?p:i.nextTick;g.WritableState=S;var l=r(10);l.inherits=r(6);var c={deprecate:r(37)},u=r(20),y=r(12).Buffer,h=o.Uint8Array||function(){};var f,d=r(21);function _(){}function S(e,t){n=n||r(7),e=e||{};var p=t instanceof n;this.objectMode=!!e.objectMode,p&&(this.objectMode=this.objectMode||!!e.writableObjectMode);var o=e.highWaterMark,l=e.writableHighWaterMark,c=this.objectMode?16:16384;this.highWaterMark=o||0===o?o:p&&(l||0===l)?l:c,this.highWaterMark=Math.floor(this.highWaterMark),this.finalCalled=!1,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1,this.destroyed=!1;var u=!1===e.decodeStrings;this.decodeStrings=!u,this.defaultEncoding=e.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.corked=0,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(e){!function(e,t){var r=e._writableState,p=r.sync,o=r.writecb;if(function(e){e.writing=!1,e.writecb=null,e.length-=e.writelen,e.writelen=0}(r),t)!function(e,t,r,p,o){--t.pendingcb,r?(i.nextTick(o,p),i.nextTick(L,e,t),e._writableState.errorEmitted=!0,e.emit("error",p)):(o(p),e._writableState.errorEmitted=!0,e.emit("error",p),L(e,t))}(e,r,p,t,o);else{var s=b(r);s||r.corked||r.bufferProcessing||!r.bufferedRequest||m(e,r),p?a(E,e,r,s,o):E(e,r,s,o)}}(t,e)},this.writecb=null,this.writelen=0,this.bufferedRequest=null,this.lastBufferedRequest=null,this.pendingcb=0,this.prefinished=!1,this.errorEmitted=!1,this.bufferedRequestCount=0,this.corkedRequestsFree=new s(this)}function g(e){if(n=n||r(7),!(f.call(g,this)||this instanceof n))return new g(e);this._writableState=new S(e,this),this.writable=!0,e&&("function"==typeof e.write&&(this._write=e.write),"function"==typeof e.writev&&(this._writev=e.writev),"function"==typeof e.destroy&&(this._destroy=e.destroy),"function"==typeof e.final&&(this._final=e.final)),u.call(this)}function w(e,t,r,p,o,i,s){t.writelen=p,t.writecb=s,t.writing=!0,t.sync=!0,r?e._writev(o,t.onwrite):e._write(o,i,t.onwrite),t.sync=!1}function E(e,t,r,p){r||function(e,t){0===t.length&&t.needDrain&&(t.needDrain=!1,e.emit("drain"))}(e,t),t.pendingcb--,p(),L(e,t)}function m(e,t){t.bufferProcessing=!0;var r=t.bufferedRequest;if(e._writev&&r&&r.next){var p=t.bufferedRequestCount,o=new Array(p),i=t.corkedRequestsFree;i.entry=r;for(var n=0,a=!0;r;)o[n]=r,r.isBuf||(a=!1),r=r.next,n+=1;o.allBuffers=a,w(e,t,!0,t.length,o,"",i.finish),t.pendingcb++,t.lastBufferedRequest=null,i.next?(t.corkedRequestsFree=i.next,i.next=null):t.corkedRequestsFree=new s(t),t.bufferedRequestCount=0}else{for(;r;){var l=r.chunk,c=r.encoding,u=r.callback;if(w(e,t,!1,t.objectMode?1:l.length,l,c,u),r=r.next,t.bufferedRequestCount--,t.writing)break}null===r&&(t.lastBufferedRequest=null)}t.bufferedRequest=r,t.bufferProcessing=!1}function b(e){return e.ending&&0===e.length&&null===e.bufferedRequest&&!e.finished&&!e.writing}function v(e,t){e._final((function(r){t.pendingcb--,r&&e.emit("error",r),t.prefinished=!0,e.emit("prefinish"),L(e,t)}))}function L(e,t){var r=b(t);return r&&(!function(e,t){t.prefinished||t.finalCalled||("function"==typeof e._final?(t.pendingcb++,t.finalCalled=!0,i.nextTick(v,e,t)):(t.prefinished=!0,e.emit("prefinish")))}(e,t),0===t.pendingcb&&(t.finished=!0,e.emit("finish"))),r}l.inherits(g,u),S.prototype.getBuffer=function(){for(var e=this.bufferedRequest,t=[];e;)t.push(e),e=e.next;return t},function(){try{Object.defineProperty(S.prototype,"buffer",{get:c.deprecate((function(){return this.getBuffer()}),"_writableState.buffer is deprecated. Use _writableState.getBuffer instead.","DEP0003")})}catch(e){}}(),"function"==typeof Symbol&&Symbol.hasInstance&&"function"==typeof Function.prototype[Symbol.hasInstance]?(f=Function.prototype[Symbol.hasInstance],Object.defineProperty(g,Symbol.hasInstance,{value:function(e){return!!f.call(this,e)||this===g&&(e&&e._writableState instanceof S)}})):f=function(e){return e instanceof this},g.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe, not readable"))},g.prototype.write=function(e,t,r){var p,o=this._writableState,s=!1,n=!o.objectMode&&(p=e,y.isBuffer(p)||p instanceof h);return n&&!y.isBuffer(e)&&(e=function(e){return y.from(e)}(e)),"function"==typeof t&&(r=t,t=null),n?t="buffer":t||(t=o.defaultEncoding),"function"!=typeof r&&(r=_),o.ended?function(e,t){var r=new Error("write after end");e.emit("error",r),i.nextTick(t,r)}(this,r):(n||function(e,t,r,p){var o=!0,s=!1;return null===r?s=new TypeError("May not write null values to stream"):"string"==typeof r||void 0===r||t.objectMode||(s=new TypeError("Invalid non-string/buffer chunk")),s&&(e.emit("error",s),i.nextTick(p,s),o=!1),o}(this,o,e,r))&&(o.pendingcb++,s=function(e,t,r,p,o,i){if(!r){var s=function(e,t,r){e.objectMode||!1===e.decodeStrings||"string"!=typeof t||(t=y.from(t,r));return t}(t,p,o);p!==s&&(r=!0,o="buffer",p=s)}var n=t.objectMode?1:p.length;t.length+=n;var a=t.length-1))throw new TypeError("Unknown encoding: "+e);return this._writableState.defaultEncoding=e,this},Object.defineProperty(g.prototype,"writableHighWaterMark",{enumerable:!1,get:function(){return this._writableState.highWaterMark}}),g.prototype._write=function(e,t,r){r(new Error("_write() is not implemented"))},g.prototype._writev=null,g.prototype.end=function(e,t,r){var p=this._writableState;"function"==typeof e?(r=e,e=null,t=null):"function"==typeof t&&(r=t,t=null),null!=e&&this.write(e,t),p.corked&&(p.corked=1,this.uncork()),p.ending||p.finished||function(e,t,r){t.ending=!0,L(e,t),r&&(t.finished?i.nextTick(r):e.once("finish",r));t.ended=!0,e.writable=!1}(this,p,r)},Object.defineProperty(g.prototype,"destroyed",{get:function(){return void 0!==this._writableState&&this._writableState.destroyed},set:function(e){this._writableState&&(this._writableState.destroyed=e)}}),g.prototype.destroy=d.destroy,g.prototype._undestroy=d.undestroy,g.prototype._destroy=function(e,t){this.end(),t(e)}}).call(this,r(9),r(35).setImmediate,r(5))},function(e,t){var r={}.toString;e.exports=Array.isArray||function(e){return"[object Array]"==r.call(e)}},function(e,t,r){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.Parser=void 0;var p=r(28),o={},i={uint8:1,uint16le:2,uint16be:2,uint32le:4,uint32be:4,int8:1,int16le:2,int16be:2,int32le:4,int32be:4,int64be:8,int64le:8,uint64be:8,uint64le:8,floatle:4,floatbe:4,doublele:8,doublebe:8},s={uint8:"Uint8",uint16le:"Uint16",uint16be:"Uint16",uint32le:"Uint32",uint32be:"Uint32",int8:"Int8",int16le:"Int16",int16be:"Int16",int32le:"Int32",int32be:"Int32",int64be:"BigInt64",int64le:"BigInt64",uint64be:"BigUint64",uint64le:"BigUint64",floatle:"Float32",floatbe:"Float32",doublele:"Float64",doublebe:"Float64"},n={uint8:!1,uint16le:!0,uint16be:!1,uint32le:!0,uint32be:!1,int8:!1,int16le:!0,int16be:!1,int32le:!0,int32be:!1,int64be:!1,int64le:!0,uint64be:!1,uint64le:!0,floatle:!0,floatbe:!1,doublele:!0,doublebe:!1},a=function(){function e(){this.varName="",this.type="",this.options={},this.next=null,this.head=null,this.compiled=null,this.endian="be",this.constructorFn=null,this.alias=null}return e.start=function(){return new e},e.prototype.primitiveGenerateN=function(e,t){var r=s[e],p=n[e];t.pushCode(t.generateVariable(this.varName)+" = dataView.get"+r+"(offset, "+p+");"),t.pushCode("offset += "+i[e]+";")},e.prototype.primitiveN=function(e,t,r){return this.setNextParser(e,t,r)},e.prototype.useThisEndian=function(e){return e+this.endian.toLowerCase()},e.prototype.uint8=function(e,t){return this.primitiveN("uint8",e,t)},e.prototype.uint16=function(e,t){return this.primitiveN(this.useThisEndian("uint16"),e,t)},e.prototype.uint16le=function(e,t){return this.primitiveN("uint16le",e,t)},e.prototype.uint16be=function(e,t){return this.primitiveN("uint16be",e,t)},e.prototype.uint32=function(e,t){return this.primitiveN(this.useThisEndian("uint32"),e,t)},e.prototype.uint32le=function(e,t){return this.primitiveN("uint32le",e,t)},e.prototype.uint32be=function(e,t){return this.primitiveN("uint32be",e,t)},e.prototype.int8=function(e,t){return this.primitiveN("int8",e,t)},e.prototype.int16=function(e,t){return this.primitiveN(this.useThisEndian("int16"),e,t)},e.prototype.int16le=function(e,t){return this.primitiveN("int16le",e,t)},e.prototype.int16be=function(e,t){return this.primitiveN("int16be",e,t)},e.prototype.int32=function(e,t){return this.primitiveN(this.useThisEndian("int32"),e,t)},e.prototype.int32le=function(e,t){return this.primitiveN("int32le",e,t)},e.prototype.int32be=function(e,t){return this.primitiveN("int32be",e,t)},e.prototype.bigIntVersionCheck=function(){if(!DataView.prototype.getBigInt64)throw new Error("BigInt64 is unsupported in this runtime")},e.prototype.int64=function(e,t){return this.bigIntVersionCheck(),this.primitiveN(this.useThisEndian("int64"),e,t)},e.prototype.int64be=function(e,t){return this.bigIntVersionCheck(),this.primitiveN("int64be",e,t)},e.prototype.int64le=function(e,t){return this.bigIntVersionCheck(),this.primitiveN("int64le",e,t)},e.prototype.uint64=function(e,t){return this.bigIntVersionCheck(),this.primitiveN(this.useThisEndian("uint64"),e,t)},e.prototype.uint64be=function(e,t){return this.bigIntVersionCheck(),this.primitiveN("uint64be",e,t)},e.prototype.uint64le=function(e,t){return this.bigIntVersionCheck(),this.primitiveN("uint64le",e,t)},e.prototype.floatle=function(e,t){return this.primitiveN("floatle",e,t)},e.prototype.floatbe=function(e,t){return this.primitiveN("floatbe",e,t)},e.prototype.doublele=function(e,t){return this.primitiveN("doublele",e,t)},e.prototype.doublebe=function(e,t){return this.primitiveN("doublebe",e,t)},e.prototype.bitN=function(e,t,r){return r||(r={}),r.length=e,this.setNextParser("bit",t,r)},e.prototype.bit1=function(e,t){return this.bitN(1,e,t)},e.prototype.bit2=function(e,t){return this.bitN(2,e,t)},e.prototype.bit3=function(e,t){return this.bitN(3,e,t)},e.prototype.bit4=function(e,t){return this.bitN(4,e,t)},e.prototype.bit5=function(e,t){return this.bitN(5,e,t)},e.prototype.bit6=function(e,t){return this.bitN(6,e,t)},e.prototype.bit7=function(e,t){return this.bitN(7,e,t)},e.prototype.bit8=function(e,t){return this.bitN(8,e,t)},e.prototype.bit9=function(e,t){return this.bitN(9,e,t)},e.prototype.bit10=function(e,t){return this.bitN(10,e,t)},e.prototype.bit11=function(e,t){return this.bitN(11,e,t)},e.prototype.bit12=function(e,t){return this.bitN(12,e,t)},e.prototype.bit13=function(e,t){return this.bitN(13,e,t)},e.prototype.bit14=function(e,t){return this.bitN(14,e,t)},e.prototype.bit15=function(e,t){return this.bitN(15,e,t)},e.prototype.bit16=function(e,t){return this.bitN(16,e,t)},e.prototype.bit17=function(e,t){return this.bitN(17,e,t)},e.prototype.bit18=function(e,t){return this.bitN(18,e,t)},e.prototype.bit19=function(e,t){return this.bitN(19,e,t)},e.prototype.bit20=function(e,t){return this.bitN(20,e,t)},e.prototype.bit21=function(e,t){return this.bitN(21,e,t)},e.prototype.bit22=function(e,t){return this.bitN(22,e,t)},e.prototype.bit23=function(e,t){return this.bitN(23,e,t)},e.prototype.bit24=function(e,t){return this.bitN(24,e,t)},e.prototype.bit25=function(e,t){return this.bitN(25,e,t)},e.prototype.bit26=function(e,t){return this.bitN(26,e,t)},e.prototype.bit27=function(e,t){return this.bitN(27,e,t)},e.prototype.bit28=function(e,t){return this.bitN(28,e,t)},e.prototype.bit29=function(e,t){return this.bitN(29,e,t)},e.prototype.bit30=function(e,t){return this.bitN(30,e,t)},e.prototype.bit31=function(e,t){return this.bitN(31,e,t)},e.prototype.bit32=function(e,t){return this.bitN(32,e,t)},e.prototype.namely=function(e){return o[e]=this,this.alias=e,this},e.prototype.skip=function(e,t){return this.seek(e,t)},e.prototype.seek=function(e,t){if(t&&t.assert)throw new Error("assert option on seek is not allowed.");return this.setNextParser("seek","",{length:e})},e.prototype.string=function(e,t){if(!t.zeroTerminated&&!t.length&&!t.greedy)throw new Error("Neither length, zeroTerminated, nor greedy is defined for string.");if((t.zeroTerminated||t.length)&&t.greedy)throw new Error("greedy is mutually exclusive with length and zeroTerminated for string.");if(t.stripNull&&!t.length&&!t.greedy)throw new Error("Length or greedy must be defined if stripNull is defined.");return t.encoding=t.encoding||"utf8",this.setNextParser("string",e,t)},e.prototype.buffer=function(e,t){if(!t.length&&!t.readUntil)throw new Error("Length nor readUntil is defined in buffer parser");return this.setNextParser("buffer",e,t)},e.prototype.array=function(e,t){if(!t.readUntil&&!t.length&&!t.lengthInBytes)throw new Error("Length option of array is not defined.");if(!t.type)throw new Error("Type option of array is not defined.");if("string"==typeof t.type&&!o[t.type]&&Object.keys(i).indexOf(t.type)<0)throw new Error('Specified primitive type "'+t.type+'" is not supported.');return this.setNextParser("array",e,t)},e.prototype.choice=function(e,t){if("object"!=typeof t&&"object"==typeof e&&(t=e,e=null),!t.tag)throw new Error("Tag option of array is not defined.");if(!t.choices)throw new Error("Choices option of array is not defined.");return Object.keys(t.choices).forEach((function(r){var p=parseInt(r,10),s=t.choices[p];if(isNaN(p))throw new Error("Key of choices must be a number.");if(!s)throw new Error("Choice Case "+r+" of "+e+" is not valid.");if("string"==typeof s&&!o[s]&&Object.keys(i).indexOf(s)<0)throw new Error('Specified primitive type "'+s+'" is not supported.')})),this.setNextParser("choice",e,t)},e.prototype.nest=function(t,r){if("object"!=typeof r&&"object"==typeof t&&(r=t,t=null),!r.type)throw new Error("Type option of nest is not defined.");if(!(r.type instanceof e||o[r.type]))throw new Error("Type option of nest must be a Parser object.");if(!(r.type instanceof e||t))throw new Error("options.type must be a object if variable name is omitted.");return this.setNextParser("nest",t,r)},e.prototype.pointer=function(t,r){if(!r.offset)throw new Error("Offset option of pointer is not defined.");if(!r.type)throw new Error("Type option of pointer is not defined.");if("string"==typeof r.type){if(Object.keys(i).indexOf(r.type)<0&&!o[r.type])throw new Error('Specified type "'+r.type+'" is not supported.')}else if(!(r.type instanceof e))throw new Error("Type option of pointer must be a string or a Parser object.");return this.setNextParser("pointer",t,r)},e.prototype.saveOffset=function(e,t){return this.setNextParser("saveOffset",e,t)},e.prototype.endianess=function(e){switch(e.toLowerCase()){case"little":this.endian="le";break;case"big":this.endian="be";break;default:throw new Error("Invalid endianess: "+e)}return this},e.prototype.create=function(e){if(!(e instanceof Function))throw new Error("Constructor must be a Function object.");return this.constructorFn=e,this},e.prototype.getContext=function(e){var t=new p.Context(e);return t.pushCode("var dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.length);"),this.alias?(this.addAliasedCode(t),t.pushCode("return ___parser_"+this.alias+"(0).result;")):this.addRawCode(t),t},e.prototype.getCode=function(){return this.getContext().code},e.prototype.addRawCode=function(e){e.pushCode("var offset = 0;"),this.constructorFn?e.pushCode("var vars = new constructorFn();"):e.pushCode("var vars = {};"),this.generate(e),this.resolveReferences(e),e.pushCode("return vars;")},e.prototype.addAliasedCode=function(e){return e.pushCode("function ___parser_"+this.alias+"(offset) {"),this.constructorFn?e.pushCode("var vars = new constructorFn();"):e.pushCode("var vars = {};"),this.generate(e),e.markResolved(this.alias),this.resolveReferences(e),e.pushCode("return { offset: offset, result: vars };"),e.pushCode("}"),e},e.prototype.resolveReferences=function(e){var t=e.getUnresolvedReferences();e.markRequested(t),t.forEach((function(t){o[t].addAliasedCode(e)}))},e.prototype.compile=function(){var e=this.getContext("imports");this.compiled=new Function("imports","TextDecoder","return function (buffer, constructorFn) { "+e.code+" };")(e.imports,"undefined"==typeof TextDecoder?r(18).TextDecoder:TextDecoder)},e.prototype.sizeOf=function(){var t=NaN;if(Object.keys(i).indexOf(this.type)>=0)t=i[this.type];else if("string"===this.type&&"number"==typeof this.options.length)t=this.options.length;else if("buffer"===this.type&&"number"==typeof this.options.length)t=this.options.length;else if("array"===this.type&&"number"==typeof this.options.length){var r=NaN;"string"==typeof this.options.type?r=i[this.options.type]:this.options.type instanceof e&&(r=this.options.type.sizeOf()),t=this.options.length*r}else"seek"===this.type?t=this.options.length:"nest"===this.type?t=this.options.type.sizeOf():this.type||(t=0);return this.next&&(t+=this.next.sizeOf()),t},e.prototype.parse=function(e){return this.compiled||this.compile(),this.compiled(e,this.constructorFn)},e.prototype.setNextParser=function(t,r,p){var o=new e;return o.type=t,o.varName=r,o.options=p||o.options,o.endian=this.endian,this.head?this.head.next=o:this.next=o,this.head=o,this},e.prototype.generate=function(e){if(this.type){switch(this.type){case"uint8":case"uint16le":case"uint16be":case"uint32le":case"uint32be":case"int8":case"int16le":case"int16be":case"int32le":case"int32be":case"int64be":case"int64le":case"uint64be":case"uint64le":case"floatle":case"floatbe":case"doublele":case"doublebe":this.primitiveGenerateN(this.type,e);break;case"bit":this.generateBit(e);break;case"string":this.generateString(e);break;case"buffer":this.generateBuffer(e);break;case"seek":this.generateSeek(e);break;case"nest":this.generateNest(e);break;case"array":this.generateArray(e);break;case"choice":this.generateChoice(e);break;case"pointer":this.generatePointer(e);break;case"saveOffset":this.generateSaveOffset(e)}this.generateAssert(e)}var t=e.generateVariable(this.varName);return this.options.formatter&&this.generateFormatter(e,t,this.options.formatter),this.generateNext(e)},e.prototype.generateAssert=function(e){if(this.options.assert){var t=e.generateVariable(this.varName);switch(typeof this.options.assert){case"function":var r=e.addImport(this.options.assert);e.pushCode("if (!"+r+".call(vars, "+t+")) {");break;case"number":e.pushCode("if ("+this.options.assert+" !== "+t+") {");break;case"string":e.pushCode('if ("'+this.options.assert+'" !== '+t+") {");break;default:throw new Error("Assert option supports only strings, numbers and assert functions.")}e.generateError('"Assert error: '+t+' is " + '+this.options.assert),e.pushCode("}")}},e.prototype.generateNext=function(e){return this.next&&(e=this.next.generate(e)),e},e.prototype.generateBit=function(e){var t=JSON.parse(JSON.stringify(this));if(t.varName=e.generateVariable(t.varName),e.bitFields.push(t),!this.next||this.next&&["bit","nest"].indexOf(this.next.type)<0){var r=0;e.bitFields.forEach((function(e){return r+=e.options.length}));var p=e.generateTmpVariable();if(r<=8)e.pushCode("var "+p+" = dataView.getUint8(offset);"),r=8;else if(r<=16)e.pushCode("var "+p+" = dataView.getUint16(offset);"),r=16;else if(r<=24){var o=e.generateTmpVariable(),i=e.generateTmpVariable();e.pushCode("var "+o+" = dataView.getUint16(offset);"),e.pushCode("var "+i+" = dataView.getUint8(offset + 2);"),e.pushCode("var "+p+" = ("+o+" << 8) | "+i+";"),r=24}else{if(!(r<=32))throw new Error("Currently, bit field sequence longer than 4-bytes is not supported.");e.pushCode("var "+p+" = dataView.getUint32(offset);"),r=32}e.pushCode("offset += "+r/8+";");var s=0,n="be"===this.endian;e.bitFields.forEach((function(t){var o=t.options.length,i=n?r-s-o:s,a=(1<> "+i+" & "+a+";"),s+=o})),e.bitFields=[]}},e.prototype.generateSeek=function(e){var t=e.generateOption(this.options.length);e.pushCode("offset += "+t+";")},e.prototype.generateString=function(e){var t=e.generateVariable(this.varName),r=e.generateTmpVariable(),p=this.options.encoding,o="hex"===p.toLowerCase(),i='b => b.toString(16).padStart(2, "0")';if(this.options.length&&this.options.zeroTerminated){var s=this.options.length;e.pushCode("var "+r+" = offset;"),e.pushCode("while(dataView.getUint8(offset++) !== 0 && offset - "+r+" < "+s+");");var n="offset - "+r+" < "+s+" ? offset - 1 : offset";e.pushCode(o?t+" = Array.from(buffer.subarray("+r+", "+n+"), "+i+").join('');":t+" = new TextDecoder('"+p+"').decode(buffer.subarray("+r+", "+n+"));")}else if(this.options.length){s=e.generateOption(this.options.length);e.pushCode(o?t+" = Array.from(buffer.subarray(offset, offset + "+s+"), "+i+").join('');":t+" = new TextDecoder('"+p+"').decode(buffer.subarray(offset, offset + "+s+"));"),e.pushCode("offset += "+s+";")}else this.options.zeroTerminated?(e.pushCode("var "+r+" = offset;"),e.pushCode("while(dataView.getUint8(offset++) !== 0);"),e.pushCode(o?t+" = Array.from(buffer.subarray("+r+", offset - 1)), "+i+").join('');":t+" = new TextDecoder('"+p+"').decode(buffer.subarray("+r+", offset - 1));")):this.options.greedy&&(e.pushCode("var "+r+" = offset;"),e.pushCode("while(buffer.length > offset++);"),e.pushCode(o?t+" = Array.from(buffer.subarray("+r+", offset)), "+i+").join('');":t+" = new TextDecoder('"+p+"').decode(buffer.subarray("+r+", offset));"));this.options.stripNull&&e.pushCode(t+" = "+t+".replace(/\\x00+$/g, '')")},e.prototype.generateBuffer=function(e){var t=e.generateVariable(this.varName);if("function"==typeof this.options.readUntil){var r=this.options.readUntil,p=e.generateTmpVariable(),o=e.generateTmpVariable();e.pushCode("var "+p+" = offset;"),e.pushCode("var "+o+" = 0;"),e.pushCode("while (offset < buffer.length) {"),e.pushCode(o+" = dataView.getUint8(offset);");var i=e.addImport(r);e.pushCode("if ("+i+".call(this, "+o+", buffer.subarray(offset))) break;"),e.pushCode("offset += 1;"),e.pushCode("}"),e.pushCode(t+" = buffer.subarray("+p+", offset);")}else if("eof"===this.options.readUntil)e.pushCode(t+" = buffer.subarray(offset);");else{var s=e.generateOption(this.options.length);e.pushCode(t+" = buffer.subarray(offset, offset + "+s+");"),e.pushCode("offset += "+s+";")}this.options.clone&&e.pushCode(t+" = buffer.constructor.from("+t+");")},e.prototype.generateArray=function(t){var r=t.generateOption(this.options.length),p=t.generateOption(this.options.lengthInBytes),a=this.options.type,l=t.generateTmpVariable(),c=t.generateVariable(this.varName),u=t.generateTmpVariable(),y=this.options.key,h="string"==typeof y;if(h?t.pushCode(c+" = {};"):t.pushCode(c+" = [];"),"function"==typeof this.options.readUntil?t.pushCode("do {"):"eof"===this.options.readUntil?t.pushCode("for (var "+l+" = 0; offset < buffer.length; "+l+"++) {"):void 0!==p?t.pushCode("for (var "+l+" = offset + "+p+"; offset < "+l+"; ) {"):t.pushCode("for (var "+l+" = "+r+"; "+l+" > 0; "+l+"--) {"),"string"==typeof a)if(o[a]){var f=t.generateTmpVariable();t.pushCode("var "+f+" = ___parser_"+a+"(offset);"),t.pushCode("var "+u+" = "+f+".result; offset = "+f+".offset;"),a!==this.alias&&t.addReference(a)}else{var d=s[a],_=n[a];t.pushCode("var "+u+" = dataView.get"+d+"(offset, "+_+");"),t.pushCode("offset += "+i[a]+";")}else a instanceof e&&(t.pushCode("var "+u+" = {};"),t.pushScope(u),a.generate(t),t.popScope());if(h?t.pushCode(c+"["+u+"."+y+"] = "+u+";"):t.pushCode(c+".push("+u+");"),t.pushCode("}"),"function"==typeof this.options.readUntil){var S=this.options.readUntil,g=t.addImport(S);t.pushCode("while (!"+g+".call(this, "+u+", buffer.subarray(offset)));")}},e.prototype.generateChoiceCase=function(t,r,p){if("string"==typeof p){var a=t.generateVariable(this.varName);if(o[p]){var l=t.generateTmpVariable();t.pushCode("var "+l+" = ___parser_"+p+"(offset);"),t.pushCode(a+" = "+l+".result; offset = "+l+".offset;"),p!==this.alias&&t.addReference(p)}else{var c=s[p],u=n[p];t.pushCode(a+" = dataView.get"+c+"(offset, "+u+");"),t.pushCode("offset += "+i[p])}}else p instanceof e&&(t.pushPath(r),p.generate(t),t.popPath(r))},e.prototype.generateChoice=function(e){var t=this,r=e.generateOption(this.options.tag);this.varName&&e.pushCode(e.generateVariable(this.varName)+" = {};"),e.pushCode("switch("+r+") {"),Object.keys(this.options.choices).forEach((function(r){var p=t.options.choices[parseInt(r,10)];e.pushCode("case "+r+":"),t.generateChoiceCase(e,t.varName,p),e.pushCode("break;")})),e.pushCode("default:"),this.options.defaultChoice?this.generateChoiceCase(e,this.varName,this.options.defaultChoice):e.generateError('"Met undefined tag value " + '+r+' + " at choice"'),e.pushCode("}")},e.prototype.generateNest=function(t){var r=t.generateVariable(this.varName);if(this.options.type instanceof e)this.varName&&t.pushCode(r+" = {};"),t.pushPath(this.varName),this.options.type.generate(t),t.popPath(this.varName);else if(o[this.options.type]){var p=t.generateTmpVariable();t.pushCode("var "+p+" = ___parser_"+this.options.type+"(offset);"),t.pushCode(r+" = "+p+".result; offset = "+p+".offset;"),this.options.type!==this.alias&&t.addReference(this.options.type)}},e.prototype.generateFormatter=function(e,t,r){if("function"==typeof r){var p=e.addImport(r);e.pushCode(t+" = "+p+".call(this, "+t+");")}},e.prototype.generatePointer=function(t){var r=this.options.type,p=t.generateOption(this.options.offset),a=t.generateTmpVariable(),l=t.generateVariable(this.varName);if(t.pushCode("var "+a+" = offset;"),t.pushCode("offset = "+p+";"),this.options.type instanceof e)t.pushCode(l+" = {};"),t.pushPath(this.varName),this.options.type.generate(t),t.popPath(this.varName);else if(o[this.options.type]){var c=t.generateTmpVariable();t.pushCode("var "+c+" = ___parser_"+this.options.type+"(offset);"),t.pushCode(l+" = "+c+".result; offset = "+c+".offset;"),this.options.type!==this.alias&&t.addReference(this.options.type)}else if(Object.keys(i).indexOf(this.options.type)>=0){var u=s[r],y=n[r];t.pushCode(l+" = dataView.get"+u+"(offset, "+y+");"),t.pushCode("offset += "+i[r]+";")}t.pushCode("offset = "+a+";")},e.prototype.generateSaveOffset=function(e){var t=e.generateVariable(this.varName);e.pushCode(t+" = offset")},e}();t.Parser=a},function(e,t,r){(function(e,p){var o=/%[sdj%]/g;t.format=function(e){if(!S(e)){for(var t=[],r=0;r=i)return e;switch(e){case"%s":return String(p[r++]);case"%d":return Number(p[r++]);case"%j":try{return JSON.stringify(p[r++])}catch(e){return"[Circular]"}default:return e}})),a=p[r];r=3&&(p.depth=arguments[2]),arguments.length>=4&&(p.colors=arguments[3]),f(r)?p.showHidden=r:r&&t._extend(p,r),g(p.showHidden)&&(p.showHidden=!1),g(p.depth)&&(p.depth=2),g(p.colors)&&(p.colors=!1),g(p.customInspect)&&(p.customInspect=!0),p.colors&&(p.stylize=a),c(p,e,p.depth)}function a(e,t){var r=n.styles[t];return r?"["+n.colors[r][0]+"m"+e+"["+n.colors[r][1]+"m":e}function l(e,t){return e}function c(e,r,p){if(e.customInspect&&r&&v(r.inspect)&&r.inspect!==t.inspect&&(!r.constructor||r.constructor.prototype!==r)){var o=r.inspect(p,e);return S(o)||(o=c(e,o,p)),o}var i=function(e,t){if(g(t))return e.stylize("undefined","undefined");if(S(t)){var r="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(r,"string")}if(_(t))return e.stylize(""+t,"number");if(f(t))return e.stylize(""+t,"boolean");if(d(t))return e.stylize("null","null")}(e,r);if(i)return i;var s=Object.keys(r),n=function(e){var t={};return e.forEach((function(e,r){t[e]=!0})),t}(s);if(e.showHidden&&(s=Object.getOwnPropertyNames(r)),b(r)&&(s.indexOf("message")>=0||s.indexOf("description")>=0))return u(r);if(0===s.length){if(v(r)){var a=r.name?": "+r.name:"";return e.stylize("[Function"+a+"]","special")}if(w(r))return e.stylize(RegExp.prototype.toString.call(r),"regexp");if(m(r))return e.stylize(Date.prototype.toString.call(r),"date");if(b(r))return u(r)}var l,E="",L=!1,I=["{","}"];(h(r)&&(L=!0,I=["[","]"]),v(r))&&(E=" [Function"+(r.name?": "+r.name:"")+"]");return w(r)&&(E=" "+RegExp.prototype.toString.call(r)),m(r)&&(E=" "+Date.prototype.toUTCString.call(r)),b(r)&&(E=" "+u(r)),0!==s.length||L&&0!=r.length?p<0?w(r)?e.stylize(RegExp.prototype.toString.call(r),"regexp"):e.stylize("[Object]","special"):(e.seen.push(r),l=L?function(e,t,r,p,o){for(var i=[],s=0,n=t.length;s=0&&0,e+t.replace(/\u001b\[\d\d?m/g,"").length+1}),0)>60)return r[0]+(""===t?"":t+"\n ")+" "+e.join(",\n ")+" "+r[1];return r[0]+t+" "+e.join(", ")+" "+r[1]}(l,E,I)):I[0]+E+I[1]}function u(e){return"["+Error.prototype.toString.call(e)+"]"}function y(e,t,r,p,o,i){var s,n,a;if((a=Object.getOwnPropertyDescriptor(t,o)||{value:t[o]}).get?n=a.set?e.stylize("[Getter/Setter]","special"):e.stylize("[Getter]","special"):a.set&&(n=e.stylize("[Setter]","special")),M(p,o)||(s="["+o+"]"),n||(e.seen.indexOf(a.value)<0?(n=d(r)?c(e,a.value,null):c(e,a.value,r-1)).indexOf("\n")>-1&&(n=i?n.split("\n").map((function(e){return" "+e})).join("\n").substr(2):"\n"+n.split("\n").map((function(e){return" "+e})).join("\n")):n=e.stylize("[Circular]","special")),g(s)){if(i&&o.match(/^\d+$/))return n;(s=JSON.stringify(""+o)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(s=s.substr(1,s.length-2),s=e.stylize(s,"name")):(s=s.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),s=e.stylize(s,"string"))}return s+": "+n}function h(e){return Array.isArray(e)}function f(e){return"boolean"==typeof e}function d(e){return null===e}function _(e){return"number"==typeof e}function S(e){return"string"==typeof e}function g(e){return void 0===e}function w(e){return E(e)&&"[object RegExp]"===L(e)}function E(e){return"object"==typeof e&&null!==e}function m(e){return E(e)&&"[object Date]"===L(e)}function b(e){return E(e)&&("[object Error]"===L(e)||e instanceof Error)}function v(e){return"function"==typeof e}function L(e){return Object.prototype.toString.call(e)}function I(e){return e<10?"0"+e.toString(10):e.toString(10)}t.debuglog=function(e){if(g(i)&&(i=p.env.NODE_DEBUG||""),e=e.toUpperCase(),!s[e])if(new RegExp("\\b"+e+"\\b","i").test(i)){var r=p.pid;s[e]=function(){var p=t.format.apply(t,arguments);console.error("%s %d: %s",e,r,p)}}else s[e]=function(){};return s[e]},t.inspect=n,n.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},n.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"},t.isArray=h,t.isBoolean=f,t.isNull=d,t.isNullOrUndefined=function(e){return null==e},t.isNumber=_,t.isString=S,t.isSymbol=function(e){return"symbol"==typeof e},t.isUndefined=g,t.isRegExp=w,t.isObject=E,t.isDate=m,t.isError=b,t.isFunction=v,t.isPrimitive=function(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||void 0===e},t.isBuffer=r(29);var T=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];function U(){var e=new Date,t=[I(e.getHours()),I(e.getMinutes()),I(e.getSeconds())].join(":");return[e.getDate(),T[e.getMonth()],t].join(" ")}function M(e,t){return Object.prototype.hasOwnProperty.call(e,t)}t.log=function(){console.log("%s - %s",U(),t.format.apply(t,arguments))},t.inherits=r(6),t._extend=function(e,t){if(!t||!E(t))return e;for(var r=Object.keys(t),p=r.length;p--;)e[r[p]]=t[r[p]];return e}}).call(this,r(5),r(9))},function(e,t,r){"use strict";(function(t,p){var o=r(11);e.exports=w;var i,s=r(16);w.ReadableState=g;r(13).EventEmitter;var n=function(e,t){return e.listeners(t).length},a=r(20),l=r(12).Buffer,c=t.Uint8Array||function(){};var u=r(10);u.inherits=r(6);var y=r(32),h=void 0;h=y&&y.debuglog?y.debuglog("stream"):function(){};var f,d=r(33),_=r(21);u.inherits(w,a);var S=["error","close","destroy","pause","resume"];function g(e,t){e=e||{};var p=t instanceof(i=i||r(7));this.objectMode=!!e.objectMode,p&&(this.objectMode=this.objectMode||!!e.readableObjectMode);var o=e.highWaterMark,s=e.readableHighWaterMark,n=this.objectMode?16:16384;this.highWaterMark=o||0===o?o:p&&(s||0===s)?s:n,this.highWaterMark=Math.floor(this.highWaterMark),this.buffer=new d,this.length=0,this.pipes=null,this.pipesCount=0,this.flowing=null,this.ended=!1,this.endEmitted=!1,this.reading=!1,this.sync=!0,this.needReadable=!1,this.emittedReadable=!1,this.readableListening=!1,this.resumeScheduled=!1,this.destroyed=!1,this.defaultEncoding=e.defaultEncoding||"utf8",this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,e.encoding&&(f||(f=r(22).StringDecoder),this.decoder=new f(e.encoding),this.encoding=e.encoding)}function w(e){if(i=i||r(7),!(this instanceof w))return new w(e);this._readableState=new g(e,this),this.readable=!0,e&&("function"==typeof e.read&&(this._read=e.read),"function"==typeof e.destroy&&(this._destroy=e.destroy)),a.call(this)}function E(e,t,r,p,o){var i,s=e._readableState;null===t?(s.reading=!1,function(e,t){if(t.ended)return;if(t.decoder){var r=t.decoder.end();r&&r.length&&(t.buffer.push(r),t.length+=t.objectMode?1:r.length)}t.ended=!0,v(e)}(e,s)):(o||(i=function(e,t){var r;p=t,l.isBuffer(p)||p instanceof c||"string"==typeof t||void 0===t||e.objectMode||(r=new TypeError("Invalid non-string/buffer chunk"));var p;return r}(s,t)),i?e.emit("error",i):s.objectMode||t&&t.length>0?("string"==typeof t||s.objectMode||Object.getPrototypeOf(t)===l.prototype||(t=function(e){return l.from(e)}(t)),p?s.endEmitted?e.emit("error",new Error("stream.unshift() after end event")):m(e,s,t,!0):s.ended?e.emit("error",new Error("stream.push() after EOF")):(s.reading=!1,s.decoder&&!r?(t=s.decoder.write(t),s.objectMode||0!==t.length?m(e,s,t,!1):I(e,s)):m(e,s,t,!1))):p||(s.reading=!1));return function(e){return!e.ended&&(e.needReadable||e.lengtht.highWaterMark&&(t.highWaterMark=function(e){return e>=8388608?e=8388608:(e--,e|=e>>>1,e|=e>>>2,e|=e>>>4,e|=e>>>8,e|=e>>>16,e++),e}(e)),e<=t.length?e:t.ended?t.length:(t.needReadable=!0,0))}function v(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(h("emitReadable",t.flowing),t.emittedReadable=!0,t.sync?o.nextTick(L,e):L(e))}function L(e){h("emit readable"),e.emit("readable"),D(e)}function I(e,t){t.readingMore||(t.readingMore=!0,o.nextTick(T,e,t))}function T(e,t){for(var r=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length=t.length?(r=t.decoder?t.buffer.join(""):1===t.buffer.length?t.buffer.head.data:t.buffer.concat(t.length),t.buffer.clear()):r=function(e,t,r){var p;ei.length?i.length:e;if(s===i.length?o+=i:o+=i.slice(0,e),0===(e-=s)){s===i.length?(++p,r.next?t.head=r.next:t.head=t.tail=null):(t.head=r,r.data=i.slice(s));break}++p}return t.length-=p,o}(e,t):function(e,t){var r=l.allocUnsafe(e),p=t.head,o=1;p.data.copy(r),e-=p.data.length;for(;p=p.next;){var i=p.data,s=e>i.length?i.length:e;if(i.copy(r,r.length-e,0,s),0===(e-=s)){s===i.length?(++o,p.next?t.head=p.next:t.head=t.tail=null):(t.head=p,p.data=i.slice(s));break}++o}return t.length-=o,r}(e,t);return p}(e,t.buffer,t.decoder),r);var r}function G(e){var t=e._readableState;if(t.length>0)throw new Error('"endReadable()" called on non-empty stream');t.endEmitted||(t.ended=!0,o.nextTick(A,t,e))}function A(e,t){e.endEmitted||0!==e.length||(e.endEmitted=!0,t.readable=!1,t.emit("end"))}function C(e,t){for(var r=0,p=e.length;r=t.highWaterMark||t.ended))return h("read: emitReadable",t.length,t.ended),0===t.length&&t.ended?G(this):v(this),null;if(0===(e=b(e,t))&&t.ended)return 0===t.length&&G(this),null;var p,o=t.needReadable;return h("need readable",o),(0===t.length||t.length-e0?O(e,t):null)?(t.needReadable=!0,e=0):t.length-=e,0===t.length&&(t.ended||(t.needReadable=!0),r!==e&&t.ended&&G(this)),null!==p&&this.emit("data",p),p},w.prototype._read=function(e){this.emit("error",new Error("_read() is not implemented"))},w.prototype.pipe=function(e,t){var r=this,i=this._readableState;switch(i.pipesCount){case 0:i.pipes=e;break;case 1:i.pipes=[i.pipes,e];break;default:i.pipes.push(e)}i.pipesCount+=1,h("pipe count=%d opts=%j",i.pipesCount,t);var a=(!t||!1!==t.end)&&e!==p.stdout&&e!==p.stderr?c:w;function l(t,p){h("onunpipe"),t===r&&p&&!1===p.hasUnpiped&&(p.hasUnpiped=!0,h("cleanup"),e.removeListener("close",S),e.removeListener("finish",g),e.removeListener("drain",u),e.removeListener("error",_),e.removeListener("unpipe",l),r.removeListener("end",c),r.removeListener("end",w),r.removeListener("data",d),y=!0,!i.awaitDrain||e._writableState&&!e._writableState.needDrain||u())}function c(){h("onend"),e.end()}i.endEmitted?o.nextTick(a):r.once("end",a),e.on("unpipe",l);var u=function(e){return function(){var t=e._readableState;h("pipeOnDrain",t.awaitDrain),t.awaitDrain&&t.awaitDrain--,0===t.awaitDrain&&n(e,"data")&&(t.flowing=!0,D(e))}}(r);e.on("drain",u);var y=!1;var f=!1;function d(t){h("ondata"),f=!1,!1!==e.write(t)||f||((1===i.pipesCount&&i.pipes===e||i.pipesCount>1&&-1!==C(i.pipes,e))&&!y&&(h("false write response, pause",r._readableState.awaitDrain),r._readableState.awaitDrain++,f=!0),r.pause())}function _(t){h("onerror",t),w(),e.removeListener("error",_),0===n(e,"error")&&e.emit("error",t)}function S(){e.removeListener("finish",g),w()}function g(){h("onfinish"),e.removeListener("close",S),w()}function w(){h("unpipe"),r.unpipe(e)}return r.on("data",d),function(e,t,r){if("function"==typeof e.prependListener)return e.prependListener(t,r);e._events&&e._events[t]?s(e._events[t])?e._events[t].unshift(r):e._events[t]=[r,e._events[t]]:e.on(t,r)}(e,"error",_),e.once("close",S),e.once("finish",g),e.emit("pipe",r),i.flowing||(h("pipe resume"),r.resume()),e},w.prototype.unpipe=function(e){var t=this._readableState,r={hasUnpiped:!1};if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes||(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,t.flowing=!1,e&&e.emit("unpipe",this,r)),this;if(!e){var p=t.pipes,o=t.pipesCount;t.pipes=null,t.pipesCount=0,t.flowing=!1;for(var i=0;i>5==6?2:e>>4==14?3:e>>3==30?4:e>>6==2?-1:-2}function n(e){var t=this.lastTotal-this.lastNeed,r=function(e,t,r){if(128!=(192&t[0]))return e.lastNeed=0,"�";if(e.lastNeed>1&&t.length>1){if(128!=(192&t[1]))return e.lastNeed=1,"�";if(e.lastNeed>2&&t.length>2&&128!=(192&t[2]))return e.lastNeed=2,"�"}}(this,e);return void 0!==r?r:this.lastNeed<=e.length?(e.copy(this.lastChar,t,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal)):(e.copy(this.lastChar,t,0,e.length),void(this.lastNeed-=e.length))}function a(e,t){if((e.length-t)%2==0){var r=e.toString("utf16le",t);if(r){var p=r.charCodeAt(r.length-1);if(p>=55296&&p<=56319)return this.lastNeed=2,this.lastTotal=4,this.lastChar[0]=e[e.length-2],this.lastChar[1]=e[e.length-1],r.slice(0,-1)}return r}return this.lastNeed=1,this.lastTotal=2,this.lastChar[0]=e[e.length-1],e.toString("utf16le",t,e.length-1)}function l(e){var t=e&&e.length?this.write(e):"";if(this.lastNeed){var r=this.lastTotal-this.lastNeed;return t+this.lastChar.toString("utf16le",0,r)}return t}function c(e,t){var r=(e.length-t)%3;return 0===r?e.toString("base64",t):(this.lastNeed=3-r,this.lastTotal=3,1===r?this.lastChar[0]=e[e.length-1]:(this.lastChar[0]=e[e.length-2],this.lastChar[1]=e[e.length-1]),e.toString("base64",t,e.length-r))}function u(e){var t=e&&e.length?this.write(e):"";return this.lastNeed?t+this.lastChar.toString("base64",0,3-this.lastNeed):t}function y(e){return e.toString(this.encoding)}function h(e){return e&&e.length?this.write(e):""}t.StringDecoder=i,i.prototype.write=function(e){if(0===e.length)return"";var t,r;if(this.lastNeed){if(void 0===(t=this.fillLast(e)))return"";r=this.lastNeed,this.lastNeed=0}else r=0;return r=0)return o>0&&(e.lastNeed=o-1),o;if(--p=0)return o>0&&(e.lastNeed=o-2),o;if(--p=0)return o>0&&(2===o?o=0:e.lastNeed=o-3),o;return 0}(this,e,t);if(!this.lastNeed)return e.toString("utf8",t);this.lastTotal=r;var p=e.length-(r-this.lastNeed);return e.copy(this.lastChar,0,p),e.toString("utf8",t,p)},i.prototype.fillLast=function(e){if(this.lastNeed<=e.length)return e.copy(this.lastChar,this.lastTotal-this.lastNeed,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal);e.copy(this.lastChar,this.lastTotal-this.lastNeed,0,e.length),this.lastNeed-=e.length}},function(e,t,r){"use strict";e.exports=s;var p=r(7),o=r(10);function i(e,t){var r=this._transformState;r.transforming=!1;var p=r.writecb;if(!p)return this.emit("error",new Error("write callback called multiple times"));r.writechunk=null,r.writecb=null,null!=t&&this.push(t),p(e);var o=this._readableState;o.reading=!1,(o.needReadable||o.length>8&255^255&r],t&=65535;return t}p.exports={preambleByte:85,crc16:S,sbpIdTable:h,sbpMessageTypesTable:f,decode:function(e){var t=d.parse(e),r=h[t.msg_type];return void 0===r?(console.log("Unknown message type: ",t.msg_type),new s(t)):new r(t)},dispatch:function(t,r,o){var i,s,n=new e(0);if(void 0===o&&"function"==typeof r?i=r:(i=o,s=r),s&&!Array.isArray(s)&&-1===["function","number"].indexOf(typeof s))throw l("dispatch: messageWhitelist must be function, number, or array");var a=function(r){t.pause();try{if((n=e.concat([n,r])).length<2)return;var o=function(){var e,t,r,o,i,a,l;for(l=0;ln.length)throw new c;e=n.slice(l+1,l+6),r=n.readUInt16LE(l+1),_=n.readUInt16LE(l+3),o=n.readUInt8(l+5);var y=s&&Array.isArray(s)&&-1!==s.indexOf(r),h=s&&"number"==typeof s&&s&r,f=s&&"function"==typeof s&&s(r);if(s&&!(y||h||f))return n=n.slice(l+6+o+2),null;if(l+8+o>n.length)throw new c;a=S(n.slice(l+6,l+6+o),S(e)),i=n.readUInt16LE(l+6+o);var d=n.slice(l,l+6+o+2);if(i===a)return n=n.slice(l+6+o+2),[p.exports.decode(d),d];throw n=n.slice(l+1),new u}();if(null===o)return;var l=o[0],y=o[1];i(null,l,y)}catch(e){if(!(e instanceof c||e instanceof u))throw e}finally{t.resume(),n.length>0&&setTimeout((function(){a(new e(0))}),0)}};t.on("data",a)}},function(e){var r={function:!0,object:!0},i=r[typeof window]&&window||this,s=r[typeof t]&&t&&!t.nodeType&&t,n=r[typeof p]&&p&&!p.nodeType&&p,a=s&&n&&"object"==typeof o&&o;!a||a.global!==a&&a.window!==a&&a.self!==a||(i=a),i.SBP=e}(p.exports)}).call(this,r(8).Buffer,r(27)(e),r(5))},function(e,t,r){"use strict";t.byteLength=function(e){var t=l(e),r=t[0],p=t[1];return 3*(r+p)/4-p},t.toByteArray=function(e){for(var t,r=l(e),p=r[0],s=r[1],n=new i(function(e,t,r){return 3*(t+r)/4-r}(0,p,s)),a=0,c=s>0?p-4:p,u=0;u>16&255,n[a++]=t>>8&255,n[a++]=255&t;2===s&&(t=o[e.charCodeAt(u)]<<2|o[e.charCodeAt(u+1)]>>4,n[a++]=255&t);1===s&&(t=o[e.charCodeAt(u)]<<10|o[e.charCodeAt(u+1)]<<4|o[e.charCodeAt(u+2)]>>2,n[a++]=t>>8&255,n[a++]=255&t);return n},t.fromByteArray=function(e){for(var t,r=e.length,o=r%3,i=[],s=0,n=r-o;sn?n:s+16383));1===o?(t=e[r-1],i.push(p[t>>2]+p[t<<4&63]+"==")):2===o&&(t=(e[r-2]<<8)+e[r-1],i.push(p[t>>10]+p[t>>4&63]+p[t<<2&63]+"="));return i.join("")};for(var p=[],o=[],i="undefined"!=typeof Uint8Array?Uint8Array:Array,s="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",n=0,a=s.length;n0)throw new Error("Invalid string. Length must be a multiple of 4");var r=e.indexOf("=");return-1===r&&(r=t),[r,r===t?0:4-r%4]}function c(e,t,r){for(var o,i,s=[],n=t;n>18&63]+p[i>>12&63]+p[i>>6&63]+p[63&i]);return s.join("")}o["-".charCodeAt(0)]=62,o["_".charCodeAt(0)]=63},function(e,t){t.read=function(e,t,r,p,o){var i,s,n=8*o-p-1,a=(1<>1,c=-7,u=r?o-1:0,y=r?-1:1,h=e[t+u];for(u+=y,i=h&(1<<-c)-1,h>>=-c,c+=n;c>0;i=256*i+e[t+u],u+=y,c-=8);for(s=i&(1<<-c)-1,i>>=-c,c+=p;c>0;s=256*s+e[t+u],u+=y,c-=8);if(0===i)i=1-l;else{if(i===a)return s?NaN:1/0*(h?-1:1);s+=Math.pow(2,p),i-=l}return(h?-1:1)*s*Math.pow(2,i-p)},t.write=function(e,t,r,p,o,i){var s,n,a,l=8*i-o-1,c=(1<>1,y=23===o?Math.pow(2,-24)-Math.pow(2,-77):0,h=p?0:i-1,f=p?1:-1,d=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(n=isNaN(t)?1:0,s=c):(s=Math.floor(Math.log(t)/Math.LN2),t*(a=Math.pow(2,-s))<1&&(s--,a*=2),(t+=s+u>=1?y/a:y*Math.pow(2,1-u))*a>=2&&(s++,a/=2),s+u>=c?(n=0,s=c):s+u>=1?(n=(t*a-1)*Math.pow(2,o),s+=u):(n=t*Math.pow(2,u-1)*Math.pow(2,o),s=0));o>=8;e[r+h]=255&n,h+=f,n/=256,o-=8);for(s=s<0;e[r+h]=255&s,h+=f,s/=256,l-=8);e[r+h-f]|=128*d}},function(e,t){e.exports=function(e){return e.webpackPolyfill||(e.deprecate=function(){},e.paths=[],e.children||(e.children=[]),Object.defineProperty(e,"loaded",{enumerable:!0,get:function(){return e.l}}),Object.defineProperty(e,"id",{enumerable:!0,get:function(){return e.i}}),e.webpackPolyfill=1),e}},function(e,t,r){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.Context=void 0;var p=function(){function e(e){this.code="",this.scopes=[["vars"]],this.bitFields=[],this.tmpVariableCount=0,this.references={},this.imports=[],this.reverseImports=new Map,this.importPath=e}return e.prototype.generateVariable=function(e){var t=[],r=this.scopes[this.scopes.length-1];return t.push.apply(t,r),e&&t.push(e),t.join(".")},e.prototype.generateOption=function(e){switch(typeof e){case"number":return e.toString();case"string":return this.generateVariable(e);case"function":return this.addImport(e)+".call("+this.generateVariable()+", vars)"}},e.prototype.generateError=function(e){this.pushCode("throw new Error("+e+");")},e.prototype.generateTmpVariable=function(){return"$tmp"+this.tmpVariableCount++},e.prototype.pushCode=function(e){this.code+=e+"\n"},e.prototype.pushPath=function(e){e&&this.scopes[this.scopes.length-1].push(e)},e.prototype.popPath=function(e){e&&this.scopes[this.scopes.length-1].pop()},e.prototype.pushScope=function(e){this.scopes.push([e])},e.prototype.popScope=function(){this.scopes.pop()},e.prototype.addImport=function(e){if(!this.importPath)return"("+e+")";var t=this.reverseImports.get(e);return t||(t=this.imports.push(e)-1,this.reverseImports.set(e,t)),this.importPath+"["+t+"]"},e.prototype.addReference=function(e){this.references[e]||(this.references[e]={resolved:!1,requested:!1})},e.prototype.markResolved=function(e){this.references[e].resolved=!0},e.prototype.markRequested=function(e){var t=this;e.forEach((function(e){t.references[e].requested=!0}))},e.prototype.getUnresolvedReferences=function(){var e=this.references;return Object.keys(this.references).filter((function(t){return!e[t].resolved&&!e[t].requested}))},e}();t.Context=p},function(e,t){e.exports=function(e){return e&&"object"==typeof e&&"function"==typeof e.copy&&"function"==typeof e.fill&&"function"==typeof e.readUInt8}},function(e,t,r){(function(e){function r(e,t){for(var r=0,p=e.length-1;p>=0;p--){var o=e[p];"."===o?e.splice(p,1):".."===o?(e.splice(p,1),r++):r&&(e.splice(p,1),r--)}if(t)for(;r--;r)e.unshift("..");return e}var p=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/,o=function(e){return p.exec(e).slice(1)};function i(e,t){if(e.filter)return e.filter(t);for(var r=[],p=0;p=-1&&!p;o--){var s=o>=0?arguments[o]:e.cwd();if("string"!=typeof s)throw new TypeError("Arguments to path.resolve must be strings");s&&(t=s+"/"+t,p="/"===s.charAt(0))}return(p?"/":"")+(t=r(i(t.split("/"),(function(e){return!!e})),!p).join("/"))||"."},t.normalize=function(e){var p=t.isAbsolute(e),o="/"===s(e,-1);return(e=r(i(e.split("/"),(function(e){return!!e})),!p).join("/"))||p||(e="."),e&&o&&(e+="/"),(p?"/":"")+e},t.isAbsolute=function(e){return"/"===e.charAt(0)},t.join=function(){var e=Array.prototype.slice.call(arguments,0);return t.normalize(i(e,(function(e,t){if("string"!=typeof e)throw new TypeError("Arguments to path.join must be strings");return e})).join("/"))},t.relative=function(e,r){function p(e){for(var t=0;t=0&&""===e[r];r--);return t>r?[]:e.slice(t,r-t+1)}e=t.resolve(e).substr(1),r=t.resolve(r).substr(1);for(var o=p(e.split("/")),i=p(r.split("/")),s=Math.min(o.length,i.length),n=s,a=0;a0?this.tail.next=t:this.head=t,this.tail=t,++this.length},e.prototype.unshift=function(e){var t={data:e,next:this.head};0===this.length&&(this.tail=t),this.head=t,++this.length},e.prototype.shift=function(){if(0!==this.length){var e=this.head.data;return 1===this.length?this.head=this.tail=null:this.head=this.head.next,--this.length,e}},e.prototype.clear=function(){this.head=this.tail=null,this.length=0},e.prototype.join=function(e){if(0===this.length)return"";for(var t=this.head,r=""+t.data;t=t.next;)r+=e+t.data;return r},e.prototype.concat=function(e){if(0===this.length)return p.alloc(0);if(1===this.length)return this.head.data;for(var t=p.allocUnsafe(e>>>0),r=this.head,o=0;r;)i(r.data,t,o),o+=r.data.length,r=r.next;return t},e}(),o&&o.inspect&&o.inspect.custom&&(e.exports.prototype[o.inspect.custom]=function(){var e=o.inspect({length:this.length});return this.constructor.name+" "+e})},function(e,t){},function(e,t,r){(function(e){var p=void 0!==e&&e||"undefined"!=typeof self&&self||window,o=Function.prototype.apply;function i(e,t){this._id=e,this._clearFn=t}t.setTimeout=function(){return new i(o.call(setTimeout,p,arguments),clearTimeout)},t.setInterval=function(){return new i(o.call(setInterval,p,arguments),clearInterval)},t.clearTimeout=t.clearInterval=function(e){e&&e.close()},i.prototype.unref=i.prototype.ref=function(){},i.prototype.close=function(){this._clearFn.call(p,this._id)},t.enroll=function(e,t){clearTimeout(e._idleTimeoutId),e._idleTimeout=t},t.unenroll=function(e){clearTimeout(e._idleTimeoutId),e._idleTimeout=-1},t._unrefActive=t.active=function(e){clearTimeout(e._idleTimeoutId);var t=e._idleTimeout;t>=0&&(e._idleTimeoutId=setTimeout((function(){e._onTimeout&&e._onTimeout()}),t))},r(36),t.setImmediate="undefined"!=typeof self&&self.setImmediate||void 0!==e&&e.setImmediate||this&&this.setImmediate,t.clearImmediate="undefined"!=typeof self&&self.clearImmediate||void 0!==e&&e.clearImmediate||this&&this.clearImmediate}).call(this,r(5))},function(e,t,r){(function(e,t){!function(e,r){"use strict";if(!e.setImmediate){var p,o,i,s,n,a=1,l={},c=!1,u=e.document,y=Object.getPrototypeOf&&Object.getPrototypeOf(e);y=y&&y.setTimeout?y:e,"[object process]"==={}.toString.call(e.process)?p=function(e){t.nextTick((function(){f(e)}))}:!function(){if(e.postMessage&&!e.importScripts){var t=!0,r=e.onmessage;return e.onmessage=function(){t=!1},e.postMessage("","*"),e.onmessage=r,t}}()?e.MessageChannel?((i=new MessageChannel).port1.onmessage=function(e){f(e.data)},p=function(e){i.port2.postMessage(e)}):u&&"onreadystatechange"in u.createElement("script")?(o=u.documentElement,p=function(e){var t=u.createElement("script");t.onreadystatechange=function(){f(e),t.onreadystatechange=null,o.removeChild(t),t=null},o.appendChild(t)}):p=function(e){setTimeout(f,0,e)}:(s="setImmediate$"+Math.random()+"$",n=function(t){t.source===e&&"string"==typeof t.data&&0===t.data.indexOf(s)&&f(+t.data.slice(s.length))},e.addEventListener?e.addEventListener("message",n,!1):e.attachEvent("onmessage",n),p=function(t){e.postMessage(s+t,"*")}),y.setImmediate=function(e){"function"!=typeof e&&(e=new Function(""+e));for(var t=new Array(arguments.length-1),r=0;r=s())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+s().toString(16)+" bytes");return 0|e}function f(e,t){if(a.isBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var r=e.length;if(0===r)return 0;for(var p=!1;;)switch(t){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":case void 0:return k(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return B(e).length;default:if(p)return k(e).length;t=(""+t).toLowerCase(),p=!0}}function d(e,t,r){var p=!1;if((void 0===t||t<0)&&(t=0),t>this.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if((r>>>=0)<=(t>>>=0))return"";for(e||(e="utf8");;)switch(e){case"hex":return D(this,t,r);case"utf8":case"utf-8":return T(this,t,r);case"ascii":return U(this,t,r);case"latin1":case"binary":return M(this,t,r);case"base64":return L(this,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return O(this,t,r);default:if(p)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),p=!0}}function _(e,t,r){var p=e[t];e[t]=e[r],e[r]=p}function S(e,t,r,p,o){if(0===e.length)return-1;if("string"==typeof r?(p=r,r=0):r>2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),r=+r,isNaN(r)&&(r=o?0:e.length-1),r<0&&(r=e.length+r),r>=e.length){if(o)return-1;r=e.length-1}else if(r<0){if(!o)return-1;r=0}if("string"==typeof t&&(t=a.from(t,p)),a.isBuffer(t))return 0===t.length?-1:g(e,t,r,p,o);if("number"==typeof t)return t&=255,a.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?o?Uint8Array.prototype.indexOf.call(e,t,r):Uint8Array.prototype.lastIndexOf.call(e,t,r):g(e,[t],r,p,o);throw new TypeError("val must be string, number or Buffer")}function g(e,t,r,p,o){var i,s=1,n=e.length,a=t.length;if(void 0!==p&&("ucs2"===(p=String(p).toLowerCase())||"ucs-2"===p||"utf16le"===p||"utf-16le"===p)){if(e.length<2||t.length<2)return-1;s=2,n/=2,a/=2,r/=2}function l(e,t){return 1===s?e[t]:e.readUInt16BE(t*s)}if(o){var c=-1;for(i=r;in&&(r=n-a),i=r;i>=0;i--){for(var u=!0,y=0;yo&&(p=o):p=o;var i=t.length;if(i%2!=0)throw new TypeError("Invalid hex string");p>i/2&&(p=i/2);for(var s=0;s>8,o=r%256,i.push(o),i.push(p);return i}(t,e.length-r),e,r,p)}function L(e,t,r){return 0===t&&r===e.length?p.fromByteArray(e):p.fromByteArray(e.slice(t,r))}function T(e,t,r){r=Math.min(e.length,r);for(var p=[],o=t;o239?4:l>223?3:l>191?2:1;if(o+u<=r)switch(u){case 1:l<128&&(c=l);break;case 2:128==(192&(i=e[o+1]))&&(a=(31&l)<<6|63&i)>127&&(c=a);break;case 3:i=e[o+1],s=e[o+2],128==(192&i)&&128==(192&s)&&(a=(15&l)<<12|(63&i)<<6|63&s)>2047&&(a<55296||a>57343)&&(c=a);break;case 4:i=e[o+1],s=e[o+2],n=e[o+3],128==(192&i)&&128==(192&s)&&128==(192&n)&&(a=(15&l)<<18|(63&i)<<12|(63&s)<<6|63&n)>65535&&a<1114112&&(c=a)}null===c?(c=65533,u=1):c>65535&&(c-=65536,p.push(c>>>10&1023|55296),c=56320|1023&c),p.push(c),o+=u}return function(e){var t=e.length;if(t<=4096)return String.fromCharCode.apply(String,e);var r="",p=0;for(;p0&&(e=this.toString("hex",0,r).match(/.{2}/g).join(" "),this.length>r&&(e+=" ... ")),""},a.prototype.compare=function(e,t,r,p,o){if(!a.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===r&&(r=e?e.length:0),void 0===p&&(p=0),void 0===o&&(o=this.length),t<0||r>e.length||p<0||o>this.length)throw new RangeError("out of range index");if(p>=o&&t>=r)return 0;if(p>=o)return-1;if(t>=r)return 1;if(this===e)return 0;for(var i=(o>>>=0)-(p>>>=0),s=(r>>>=0)-(t>>>=0),n=Math.min(i,s),l=this.slice(p,o),c=e.slice(t,r),u=0;uo)&&(r=o),e.length>0&&(r<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");p||(p="utf8");for(var i=!1;;)switch(p){case"hex":return w(this,e,t,r);case"utf8":case"utf-8":return E(this,e,t,r);case"ascii":return m(this,e,t,r);case"latin1":case"binary":return b(this,e,t,r);case"base64":return v(this,e,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return I(this,e,t,r);default:if(i)throw new TypeError("Unknown encoding: "+p);p=(""+p).toLowerCase(),i=!0}},a.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};function U(e,t,r){var p="";r=Math.min(e.length,r);for(var o=t;op)&&(r=p);for(var o="",i=t;ir)throw new RangeError("Trying to access beyond buffer length")}function A(e,t,r,p,o,i){if(!a.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>o||te.length)throw new RangeError("Index out of range")}function C(e,t,r,p){t<0&&(t=65535+t+1);for(var o=0,i=Math.min(e.length-r,2);o>>8*(p?o:1-o)}function R(e,t,r,p){t<0&&(t=4294967295+t+1);for(var o=0,i=Math.min(e.length-r,4);o>>8*(p?o:3-o)&255}function P(e,t,r,p,o,i){if(r+p>e.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function N(e,t,r,p,i){return i||P(e,0,r,4),o.write(e,t,r,p,23,4),r+4}function j(e,t,r,p,i){return i||P(e,0,r,8),o.write(e,t,r,p,52,8),r+8}a.prototype.slice=function(e,t){var r,p=this.length;if((e=~~e)<0?(e+=p)<0&&(e=0):e>p&&(e=p),(t=void 0===t?p:~~t)<0?(t+=p)<0&&(t=0):t>p&&(t=p),t0&&(o*=256);)p+=this[e+--t]*o;return p},a.prototype.readUInt8=function(e,t){return t||G(e,1,this.length),this[e]},a.prototype.readUInt16LE=function(e,t){return t||G(e,2,this.length),this[e]|this[e+1]<<8},a.prototype.readUInt16BE=function(e,t){return t||G(e,2,this.length),this[e]<<8|this[e+1]},a.prototype.readUInt32LE=function(e,t){return t||G(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},a.prototype.readUInt32BE=function(e,t){return t||G(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},a.prototype.readIntLE=function(e,t,r){e|=0,t|=0,r||G(e,t,this.length);for(var p=this[e],o=1,i=0;++i=(o*=128)&&(p-=Math.pow(2,8*t)),p},a.prototype.readIntBE=function(e,t,r){e|=0,t|=0,r||G(e,t,this.length);for(var p=t,o=1,i=this[e+--p];p>0&&(o*=256);)i+=this[e+--p]*o;return i>=(o*=128)&&(i-=Math.pow(2,8*t)),i},a.prototype.readInt8=function(e,t){return t||G(e,1,this.length),128&this[e]?-1*(255-this[e]+1):this[e]},a.prototype.readInt16LE=function(e,t){t||G(e,2,this.length);var r=this[e]|this[e+1]<<8;return 32768&r?4294901760|r:r},a.prototype.readInt16BE=function(e,t){t||G(e,2,this.length);var r=this[e+1]|this[e]<<8;return 32768&r?4294901760|r:r},a.prototype.readInt32LE=function(e,t){return t||G(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},a.prototype.readInt32BE=function(e,t){return t||G(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},a.prototype.readFloatLE=function(e,t){return t||G(e,4,this.length),o.read(this,e,!0,23,4)},a.prototype.readFloatBE=function(e,t){return t||G(e,4,this.length),o.read(this,e,!1,23,4)},a.prototype.readDoubleLE=function(e,t){return t||G(e,8,this.length),o.read(this,e,!0,52,8)},a.prototype.readDoubleBE=function(e,t){return t||G(e,8,this.length),o.read(this,e,!1,52,8)},a.prototype.writeUIntLE=function(e,t,r,p){(e=+e,t|=0,r|=0,p)||A(this,e,t,r,Math.pow(2,8*r)-1,0);var o=1,i=0;for(this[t]=255&e;++i=0&&(i*=256);)this[t+o]=e/i&255;return t+r},a.prototype.writeUInt8=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,1,255,0),a.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),this[t]=255&e,t+1},a.prototype.writeUInt16LE=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,2,65535,0),a.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):C(this,e,t,!0),t+2},a.prototype.writeUInt16BE=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,2,65535,0),a.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):C(this,e,t,!1),t+2},a.prototype.writeUInt32LE=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,4,4294967295,0),a.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):R(this,e,t,!0),t+4},a.prototype.writeUInt32BE=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,4,4294967295,0),a.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):R(this,e,t,!1),t+4},a.prototype.writeIntLE=function(e,t,r,p){if(e=+e,t|=0,!p){var o=Math.pow(2,8*r-1);A(this,e,t,r,o-1,-o)}var i=0,s=1,n=0;for(this[t]=255&e;++i>0)-n&255;return t+r},a.prototype.writeIntBE=function(e,t,r,p){if(e=+e,t|=0,!p){var o=Math.pow(2,8*r-1);A(this,e,t,r,o-1,-o)}var i=r-1,s=1,n=0;for(this[t+i]=255&e;--i>=0&&(s*=256);)e<0&&0===n&&0!==this[t+i+1]&&(n=1),this[t+i]=(e/s>>0)-n&255;return t+r},a.prototype.writeInt8=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,1,127,-128),a.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},a.prototype.writeInt16LE=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,2,32767,-32768),a.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):C(this,e,t,!0),t+2},a.prototype.writeInt16BE=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,2,32767,-32768),a.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):C(this,e,t,!1),t+2},a.prototype.writeInt32LE=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,4,2147483647,-2147483648),a.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):R(this,e,t,!0),t+4},a.prototype.writeInt32BE=function(e,t,r){return e=+e,t|=0,r||A(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),a.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):R(this,e,t,!1),t+4},a.prototype.writeFloatLE=function(e,t,r){return N(this,e,t,!0,r)},a.prototype.writeFloatBE=function(e,t,r){return N(this,e,t,!1,r)},a.prototype.writeDoubleLE=function(e,t,r){return j(this,e,t,!0,r)},a.prototype.writeDoubleBE=function(e,t,r){return j(this,e,t,!1,r)},a.prototype.copy=function(e,t,r,p){if(r||(r=0),p||0===p||(p=this.length),t>=e.length&&(t=e.length),t||(t=0),p>0&&p=this.length)throw new RangeError("sourceStart out of bounds");if(p<0)throw new RangeError("sourceEnd out of bounds");p>this.length&&(p=this.length),e.length-t=0;--o)e[o+t]=this[o+r];else if(i<1e3||!a.TYPED_ARRAY_SUPPORT)for(o=0;o>>=0,r=void 0===r?this.length:r>>>0,e||(e=0),"number"==typeof e)for(i=t;i55295&&r<57344){if(!o){if(r>56319){(t-=3)>-1&&i.push(239,191,189);continue}if(s+1===p){(t-=3)>-1&&i.push(239,191,189);continue}o=r;continue}if(r<56320){(t-=3)>-1&&i.push(239,191,189),o=r;continue}r=65536+(o-55296<<10|r-56320)}else o&&(t-=3)>-1&&i.push(239,191,189);if(o=null,r<128){if((t-=1)<0)break;i.push(r)}else if(r<2048){if((t-=2)<0)break;i.push(r>>6|192,63&r|128)}else if(r<65536){if((t-=3)<0)break;i.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;i.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return i}function B(e){return p.toByteArray(function(e){if((e=function(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}(e).replace(x,"")).length<2)return"";for(;e.length%4!=0;)e+="=";return e}(e))}function q(e,t,r,p){for(var o=0;o=t.length||o>=e.length);++o)t[o+r]=e[o];return o}}).call(this,r(5))},function(e,t){var r,p,o=e.exports={};function i(){throw new Error("setTimeout has not been defined")}function s(){throw new Error("clearTimeout has not been defined")}function n(e){if(r===setTimeout)return setTimeout(e,0);if((r===i||!r)&&setTimeout)return r=setTimeout,setTimeout(e,0);try{return r(e,0)}catch(t){try{return r.call(null,e,0)}catch(t){return r.call(this,e,0)}}}!function(){try{r="function"==typeof setTimeout?setTimeout:i}catch(e){r=i}try{p="function"==typeof clearTimeout?clearTimeout:s}catch(e){p=s}}();var a,l=[],c=!1,u=-1;function y(){c&&a&&(c=!1,a.length?l=a.concat(l):u=-1,l.length&&h())}function h(){if(!c){var e=n(y);c=!0;for(var t=l.length;t;){for(a=l,l=[];++u1)for(var r=1;r0&&this._events[e].length>s&&(this._events[e].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[e].length),"function"==typeof console.trace&&console.trace()),this},r.prototype.on=r.prototype.addListener,r.prototype.once=function(e,t){if(!p(t))throw TypeError("listener must be a function");var r=!1;function o(){this.removeListener(e,o),r||(r=!0,t.apply(this,arguments))}return o.listener=t,this.on(e,o),this},r.prototype.removeListener=function(e,t){var r,i,s,n;if(!p(t))throw TypeError("listener must be a function");if(!this._events||!this._events[e])return this;if(s=(r=this._events[e]).length,i=-1,r===t||p(r.listener)&&r.listener===t)delete this._events[e],this._events.removeListener&&this.emit("removeListener",e,t);else if(o(r)){for(n=s;n-- >0;)if(r[n]===t||r[n].listener&&r[n].listener===t){i=n;break}if(i<0)return this;1===r.length?(r.length=0,delete this._events[e]):r.splice(i,1),this._events.removeListener&&this.emit("removeListener",e,t)}return this},r.prototype.removeAllListeners=function(e){var t,r;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[e]&&delete this._events[e],this;if(0===arguments.length){for(t in this._events)"removeListener"!==t&&this.removeAllListeners(t);return this.removeAllListeners("removeListener"),this._events={},this}if(p(r=this._events[e]))this.removeListener(e,r);else if(r)for(;r.length;)this.removeListener(e,r[r.length-1]);return delete this._events[e],this},r.prototype.listeners=function(e){return this._events&&this._events[e]?p(this._events[e])?[this._events[e]]:this._events[e].slice():[]},r.prototype.listenerCount=function(e){if(this._events){var t=this._events[e];if(p(t))return 1;if(t)return t.length}return 0},r.listenerCount=function(e,t){return e.listenerCount(t)}},function(e,t,r){(t=e.exports=r(19)).Stream=t,t.Readable=t,t.Writable=r(15),t.Duplex=r(7),t.Transform=r(23),t.PassThrough=r(38)},function(e,t,r){"use strict";(function(t,p,o){var i=r(11);function s(e){var t=this;this.next=null,this.entry=null,this.finish=function(){!function(e,t,r){var p=e.entry;e.entry=null;for(;p;){var o=p.callback;t.pendingcb--,o(r),p=p.next}t.corkedRequestsFree?t.corkedRequestsFree.next=e:t.corkedRequestsFree=e}(t,e)}}e.exports=g;var n,a=!t.browser&&["v0.10","v0.9."].indexOf(t.version.slice(0,5))>-1?p:i.nextTick;g.WritableState=S;var l=r(10);l.inherits=r(6);var c={deprecate:r(37)},u=r(20),y=r(12).Buffer,h=o.Uint8Array||function(){};var f,d=r(21);function _(){}function S(e,t){n=n||r(7),e=e||{};var p=t instanceof n;this.objectMode=!!e.objectMode,p&&(this.objectMode=this.objectMode||!!e.writableObjectMode);var o=e.highWaterMark,l=e.writableHighWaterMark,c=this.objectMode?16:16384;this.highWaterMark=o||0===o?o:p&&(l||0===l)?l:c,this.highWaterMark=Math.floor(this.highWaterMark),this.finalCalled=!1,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1,this.destroyed=!1;var u=!1===e.decodeStrings;this.decodeStrings=!u,this.defaultEncoding=e.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.corked=0,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(e){!function(e,t){var r=e._writableState,p=r.sync,o=r.writecb;if(function(e){e.writing=!1,e.writecb=null,e.length-=e.writelen,e.writelen=0}(r),t)!function(e,t,r,p,o){--t.pendingcb,r?(i.nextTick(o,p),i.nextTick(I,e,t),e._writableState.errorEmitted=!0,e.emit("error",p)):(o(p),e._writableState.errorEmitted=!0,e.emit("error",p),I(e,t))}(e,r,p,t,o);else{var s=b(r);s||r.corked||r.bufferProcessing||!r.bufferedRequest||m(e,r),p?a(E,e,r,s,o):E(e,r,s,o)}}(t,e)},this.writecb=null,this.writelen=0,this.bufferedRequest=null,this.lastBufferedRequest=null,this.pendingcb=0,this.prefinished=!1,this.errorEmitted=!1,this.bufferedRequestCount=0,this.corkedRequestsFree=new s(this)}function g(e){if(n=n||r(7),!(f.call(g,this)||this instanceof n))return new g(e);this._writableState=new S(e,this),this.writable=!0,e&&("function"==typeof e.write&&(this._write=e.write),"function"==typeof e.writev&&(this._writev=e.writev),"function"==typeof e.destroy&&(this._destroy=e.destroy),"function"==typeof e.final&&(this._final=e.final)),u.call(this)}function w(e,t,r,p,o,i,s){t.writelen=p,t.writecb=s,t.writing=!0,t.sync=!0,r?e._writev(o,t.onwrite):e._write(o,i,t.onwrite),t.sync=!1}function E(e,t,r,p){r||function(e,t){0===t.length&&t.needDrain&&(t.needDrain=!1,e.emit("drain"))}(e,t),t.pendingcb--,p(),I(e,t)}function m(e,t){t.bufferProcessing=!0;var r=t.bufferedRequest;if(e._writev&&r&&r.next){var p=t.bufferedRequestCount,o=new Array(p),i=t.corkedRequestsFree;i.entry=r;for(var n=0,a=!0;r;)o[n]=r,r.isBuf||(a=!1),r=r.next,n+=1;o.allBuffers=a,w(e,t,!0,t.length,o,"",i.finish),t.pendingcb++,t.lastBufferedRequest=null,i.next?(t.corkedRequestsFree=i.next,i.next=null):t.corkedRequestsFree=new s(t),t.bufferedRequestCount=0}else{for(;r;){var l=r.chunk,c=r.encoding,u=r.callback;if(w(e,t,!1,t.objectMode?1:l.length,l,c,u),r=r.next,t.bufferedRequestCount--,t.writing)break}null===r&&(t.lastBufferedRequest=null)}t.bufferedRequest=r,t.bufferProcessing=!1}function b(e){return e.ending&&0===e.length&&null===e.bufferedRequest&&!e.finished&&!e.writing}function v(e,t){e._final((function(r){t.pendingcb--,r&&e.emit("error",r),t.prefinished=!0,e.emit("prefinish"),I(e,t)}))}function I(e,t){var r=b(t);return r&&(!function(e,t){t.prefinished||t.finalCalled||("function"==typeof e._final?(t.pendingcb++,t.finalCalled=!0,i.nextTick(v,e,t)):(t.prefinished=!0,e.emit("prefinish")))}(e,t),0===t.pendingcb&&(t.finished=!0,e.emit("finish"))),r}l.inherits(g,u),S.prototype.getBuffer=function(){for(var e=this.bufferedRequest,t=[];e;)t.push(e),e=e.next;return t},function(){try{Object.defineProperty(S.prototype,"buffer",{get:c.deprecate((function(){return this.getBuffer()}),"_writableState.buffer is deprecated. Use _writableState.getBuffer instead.","DEP0003")})}catch(e){}}(),"function"==typeof Symbol&&Symbol.hasInstance&&"function"==typeof Function.prototype[Symbol.hasInstance]?(f=Function.prototype[Symbol.hasInstance],Object.defineProperty(g,Symbol.hasInstance,{value:function(e){return!!f.call(this,e)||this===g&&(e&&e._writableState instanceof S)}})):f=function(e){return e instanceof this},g.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe, not readable"))},g.prototype.write=function(e,t,r){var p,o=this._writableState,s=!1,n=!o.objectMode&&(p=e,y.isBuffer(p)||p instanceof h);return n&&!y.isBuffer(e)&&(e=function(e){return y.from(e)}(e)),"function"==typeof t&&(r=t,t=null),n?t="buffer":t||(t=o.defaultEncoding),"function"!=typeof r&&(r=_),o.ended?function(e,t){var r=new Error("write after end");e.emit("error",r),i.nextTick(t,r)}(this,r):(n||function(e,t,r,p){var o=!0,s=!1;return null===r?s=new TypeError("May not write null values to stream"):"string"==typeof r||void 0===r||t.objectMode||(s=new TypeError("Invalid non-string/buffer chunk")),s&&(e.emit("error",s),i.nextTick(p,s),o=!1),o}(this,o,e,r))&&(o.pendingcb++,s=function(e,t,r,p,o,i){if(!r){var s=function(e,t,r){e.objectMode||!1===e.decodeStrings||"string"!=typeof t||(t=y.from(t,r));return t}(t,p,o);p!==s&&(r=!0,o="buffer",p=s)}var n=t.objectMode?1:p.length;t.length+=n;var a=t.length-1))throw new TypeError("Unknown encoding: "+e);return this._writableState.defaultEncoding=e,this},Object.defineProperty(g.prototype,"writableHighWaterMark",{enumerable:!1,get:function(){return this._writableState.highWaterMark}}),g.prototype._write=function(e,t,r){r(new Error("_write() is not implemented"))},g.prototype._writev=null,g.prototype.end=function(e,t,r){var p=this._writableState;"function"==typeof e?(r=e,e=null,t=null):"function"==typeof t&&(r=t,t=null),null!=e&&this.write(e,t),p.corked&&(p.corked=1,this.uncork()),p.ending||p.finished||function(e,t,r){t.ending=!0,I(e,t),r&&(t.finished?i.nextTick(r):e.once("finish",r));t.ended=!0,e.writable=!1}(this,p,r)},Object.defineProperty(g.prototype,"destroyed",{get:function(){return void 0!==this._writableState&&this._writableState.destroyed},set:function(e){this._writableState&&(this._writableState.destroyed=e)}}),g.prototype.destroy=d.destroy,g.prototype._undestroy=d.undestroy,g.prototype._destroy=function(e,t){this.end(),t(e)}}).call(this,r(9),r(35).setImmediate,r(5))},function(e,t){var r={}.toString;e.exports=Array.isArray||function(e){return"[object Array]"==r.call(e)}},function(e,t,r){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.Parser=void 0;var p=r(28),o={},i={uint8:1,uint16le:2,uint16be:2,uint32le:4,uint32be:4,int8:1,int16le:2,int16be:2,int32le:4,int32be:4,int64be:8,int64le:8,uint64be:8,uint64le:8,floatle:4,floatbe:4,doublele:8,doublebe:8},s={uint8:"Uint8",uint16le:"Uint16",uint16be:"Uint16",uint32le:"Uint32",uint32be:"Uint32",int8:"Int8",int16le:"Int16",int16be:"Int16",int32le:"Int32",int32be:"Int32",int64be:"BigInt64",int64le:"BigInt64",uint64be:"BigUint64",uint64le:"BigUint64",floatle:"Float32",floatbe:"Float32",doublele:"Float64",doublebe:"Float64"},n={uint8:!1,uint16le:!0,uint16be:!1,uint32le:!0,uint32be:!1,int8:!1,int16le:!0,int16be:!1,int32le:!0,int32be:!1,int64be:!1,int64le:!0,uint64be:!1,uint64le:!0,floatle:!0,floatbe:!1,doublele:!0,doublebe:!1},a=function(){function e(){this.varName="",this.type="",this.options={},this.next=null,this.head=null,this.compiled=null,this.endian="be",this.constructorFn=null,this.alias=null}return e.start=function(){return new e},e.prototype.primitiveGenerateN=function(e,t){var r=s[e],p=n[e];t.pushCode(t.generateVariable(this.varName)+" = dataView.get"+r+"(offset, "+p+");"),t.pushCode("offset += "+i[e]+";")},e.prototype.primitiveN=function(e,t,r){return this.setNextParser(e,t,r)},e.prototype.useThisEndian=function(e){return e+this.endian.toLowerCase()},e.prototype.uint8=function(e,t){return this.primitiveN("uint8",e,t)},e.prototype.uint16=function(e,t){return this.primitiveN(this.useThisEndian("uint16"),e,t)},e.prototype.uint16le=function(e,t){return this.primitiveN("uint16le",e,t)},e.prototype.uint16be=function(e,t){return this.primitiveN("uint16be",e,t)},e.prototype.uint32=function(e,t){return this.primitiveN(this.useThisEndian("uint32"),e,t)},e.prototype.uint32le=function(e,t){return this.primitiveN("uint32le",e,t)},e.prototype.uint32be=function(e,t){return this.primitiveN("uint32be",e,t)},e.prototype.int8=function(e,t){return this.primitiveN("int8",e,t)},e.prototype.int16=function(e,t){return this.primitiveN(this.useThisEndian("int16"),e,t)},e.prototype.int16le=function(e,t){return this.primitiveN("int16le",e,t)},e.prototype.int16be=function(e,t){return this.primitiveN("int16be",e,t)},e.prototype.int32=function(e,t){return this.primitiveN(this.useThisEndian("int32"),e,t)},e.prototype.int32le=function(e,t){return this.primitiveN("int32le",e,t)},e.prototype.int32be=function(e,t){return this.primitiveN("int32be",e,t)},e.prototype.bigIntVersionCheck=function(){if(!DataView.prototype.getBigInt64)throw new Error("BigInt64 is unsupported in this runtime")},e.prototype.int64=function(e,t){return this.bigIntVersionCheck(),this.primitiveN(this.useThisEndian("int64"),e,t)},e.prototype.int64be=function(e,t){return this.bigIntVersionCheck(),this.primitiveN("int64be",e,t)},e.prototype.int64le=function(e,t){return this.bigIntVersionCheck(),this.primitiveN("int64le",e,t)},e.prototype.uint64=function(e,t){return this.bigIntVersionCheck(),this.primitiveN(this.useThisEndian("uint64"),e,t)},e.prototype.uint64be=function(e,t){return this.bigIntVersionCheck(),this.primitiveN("uint64be",e,t)},e.prototype.uint64le=function(e,t){return this.bigIntVersionCheck(),this.primitiveN("uint64le",e,t)},e.prototype.floatle=function(e,t){return this.primitiveN("floatle",e,t)},e.prototype.floatbe=function(e,t){return this.primitiveN("floatbe",e,t)},e.prototype.doublele=function(e,t){return this.primitiveN("doublele",e,t)},e.prototype.doublebe=function(e,t){return this.primitiveN("doublebe",e,t)},e.prototype.bitN=function(e,t,r){return r||(r={}),r.length=e,this.setNextParser("bit",t,r)},e.prototype.bit1=function(e,t){return this.bitN(1,e,t)},e.prototype.bit2=function(e,t){return this.bitN(2,e,t)},e.prototype.bit3=function(e,t){return this.bitN(3,e,t)},e.prototype.bit4=function(e,t){return this.bitN(4,e,t)},e.prototype.bit5=function(e,t){return this.bitN(5,e,t)},e.prototype.bit6=function(e,t){return this.bitN(6,e,t)},e.prototype.bit7=function(e,t){return this.bitN(7,e,t)},e.prototype.bit8=function(e,t){return this.bitN(8,e,t)},e.prototype.bit9=function(e,t){return this.bitN(9,e,t)},e.prototype.bit10=function(e,t){return this.bitN(10,e,t)},e.prototype.bit11=function(e,t){return this.bitN(11,e,t)},e.prototype.bit12=function(e,t){return this.bitN(12,e,t)},e.prototype.bit13=function(e,t){return this.bitN(13,e,t)},e.prototype.bit14=function(e,t){return this.bitN(14,e,t)},e.prototype.bit15=function(e,t){return this.bitN(15,e,t)},e.prototype.bit16=function(e,t){return this.bitN(16,e,t)},e.prototype.bit17=function(e,t){return this.bitN(17,e,t)},e.prototype.bit18=function(e,t){return this.bitN(18,e,t)},e.prototype.bit19=function(e,t){return this.bitN(19,e,t)},e.prototype.bit20=function(e,t){return this.bitN(20,e,t)},e.prototype.bit21=function(e,t){return this.bitN(21,e,t)},e.prototype.bit22=function(e,t){return this.bitN(22,e,t)},e.prototype.bit23=function(e,t){return this.bitN(23,e,t)},e.prototype.bit24=function(e,t){return this.bitN(24,e,t)},e.prototype.bit25=function(e,t){return this.bitN(25,e,t)},e.prototype.bit26=function(e,t){return this.bitN(26,e,t)},e.prototype.bit27=function(e,t){return this.bitN(27,e,t)},e.prototype.bit28=function(e,t){return this.bitN(28,e,t)},e.prototype.bit29=function(e,t){return this.bitN(29,e,t)},e.prototype.bit30=function(e,t){return this.bitN(30,e,t)},e.prototype.bit31=function(e,t){return this.bitN(31,e,t)},e.prototype.bit32=function(e,t){return this.bitN(32,e,t)},e.prototype.namely=function(e){return o[e]=this,this.alias=e,this},e.prototype.skip=function(e,t){return this.seek(e,t)},e.prototype.seek=function(e,t){if(t&&t.assert)throw new Error("assert option on seek is not allowed.");return this.setNextParser("seek","",{length:e})},e.prototype.string=function(e,t){if(!t.zeroTerminated&&!t.length&&!t.greedy)throw new Error("Neither length, zeroTerminated, nor greedy is defined for string.");if((t.zeroTerminated||t.length)&&t.greedy)throw new Error("greedy is mutually exclusive with length and zeroTerminated for string.");if(t.stripNull&&!t.length&&!t.greedy)throw new Error("Length or greedy must be defined if stripNull is defined.");return t.encoding=t.encoding||"utf8",this.setNextParser("string",e,t)},e.prototype.buffer=function(e,t){if(!t.length&&!t.readUntil)throw new Error("Length nor readUntil is defined in buffer parser");return this.setNextParser("buffer",e,t)},e.prototype.array=function(e,t){if(!t.readUntil&&!t.length&&!t.lengthInBytes)throw new Error("Length option of array is not defined.");if(!t.type)throw new Error("Type option of array is not defined.");if("string"==typeof t.type&&!o[t.type]&&Object.keys(i).indexOf(t.type)<0)throw new Error('Specified primitive type "'+t.type+'" is not supported.');return this.setNextParser("array",e,t)},e.prototype.choice=function(e,t){if("object"!=typeof t&&"object"==typeof e&&(t=e,e=null),!t.tag)throw new Error("Tag option of array is not defined.");if(!t.choices)throw new Error("Choices option of array is not defined.");return Object.keys(t.choices).forEach((function(r){var p=parseInt(r,10),s=t.choices[p];if(isNaN(p))throw new Error("Key of choices must be a number.");if(!s)throw new Error("Choice Case "+r+" of "+e+" is not valid.");if("string"==typeof s&&!o[s]&&Object.keys(i).indexOf(s)<0)throw new Error('Specified primitive type "'+s+'" is not supported.')})),this.setNextParser("choice",e,t)},e.prototype.nest=function(t,r){if("object"!=typeof r&&"object"==typeof t&&(r=t,t=null),!r.type)throw new Error("Type option of nest is not defined.");if(!(r.type instanceof e||o[r.type]))throw new Error("Type option of nest must be a Parser object.");if(!(r.type instanceof e||t))throw new Error("options.type must be a object if variable name is omitted.");return this.setNextParser("nest",t,r)},e.prototype.pointer=function(t,r){if(!r.offset)throw new Error("Offset option of pointer is not defined.");if(!r.type)throw new Error("Type option of pointer is not defined.");if("string"==typeof r.type){if(Object.keys(i).indexOf(r.type)<0&&!o[r.type])throw new Error('Specified type "'+r.type+'" is not supported.')}else if(!(r.type instanceof e))throw new Error("Type option of pointer must be a string or a Parser object.");return this.setNextParser("pointer",t,r)},e.prototype.saveOffset=function(e,t){return this.setNextParser("saveOffset",e,t)},e.prototype.endianess=function(e){switch(e.toLowerCase()){case"little":this.endian="le";break;case"big":this.endian="be";break;default:throw new Error("Invalid endianess: "+e)}return this},e.prototype.create=function(e){if(!(e instanceof Function))throw new Error("Constructor must be a Function object.");return this.constructorFn=e,this},e.prototype.getContext=function(e){var t=new p.Context(e);return t.pushCode("var dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.length);"),this.alias?(this.addAliasedCode(t),t.pushCode("return ___parser_"+this.alias+"(0).result;")):this.addRawCode(t),t},e.prototype.getCode=function(){return this.getContext().code},e.prototype.addRawCode=function(e){e.pushCode("var offset = 0;"),this.constructorFn?e.pushCode("var vars = new constructorFn();"):e.pushCode("var vars = {};"),this.generate(e),this.resolveReferences(e),e.pushCode("return vars;")},e.prototype.addAliasedCode=function(e){return e.pushCode("function ___parser_"+this.alias+"(offset) {"),this.constructorFn?e.pushCode("var vars = new constructorFn();"):e.pushCode("var vars = {};"),this.generate(e),e.markResolved(this.alias),this.resolveReferences(e),e.pushCode("return { offset: offset, result: vars };"),e.pushCode("}"),e},e.prototype.resolveReferences=function(e){var t=e.getUnresolvedReferences();e.markRequested(t),t.forEach((function(t){o[t].addAliasedCode(e)}))},e.prototype.compile=function(){var e=this.getContext("imports");this.compiled=new Function("imports","TextDecoder","return function (buffer, constructorFn) { "+e.code+" };")(e.imports,"undefined"==typeof TextDecoder?r(18).TextDecoder:TextDecoder)},e.prototype.sizeOf=function(){var t=NaN;if(Object.keys(i).indexOf(this.type)>=0)t=i[this.type];else if("string"===this.type&&"number"==typeof this.options.length)t=this.options.length;else if("buffer"===this.type&&"number"==typeof this.options.length)t=this.options.length;else if("array"===this.type&&"number"==typeof this.options.length){var r=NaN;"string"==typeof this.options.type?r=i[this.options.type]:this.options.type instanceof e&&(r=this.options.type.sizeOf()),t=this.options.length*r}else"seek"===this.type?t=this.options.length:"nest"===this.type?t=this.options.type.sizeOf():this.type||(t=0);return this.next&&(t+=this.next.sizeOf()),t},e.prototype.parse=function(e){return this.compiled||this.compile(),this.compiled(e,this.constructorFn)},e.prototype.setNextParser=function(t,r,p){var o=new e;return o.type=t,o.varName=r,o.options=p||o.options,o.endian=this.endian,this.head?this.head.next=o:this.next=o,this.head=o,this},e.prototype.generate=function(e){if(this.type){switch(this.type){case"uint8":case"uint16le":case"uint16be":case"uint32le":case"uint32be":case"int8":case"int16le":case"int16be":case"int32le":case"int32be":case"int64be":case"int64le":case"uint64be":case"uint64le":case"floatle":case"floatbe":case"doublele":case"doublebe":this.primitiveGenerateN(this.type,e);break;case"bit":this.generateBit(e);break;case"string":this.generateString(e);break;case"buffer":this.generateBuffer(e);break;case"seek":this.generateSeek(e);break;case"nest":this.generateNest(e);break;case"array":this.generateArray(e);break;case"choice":this.generateChoice(e);break;case"pointer":this.generatePointer(e);break;case"saveOffset":this.generateSaveOffset(e)}this.generateAssert(e)}var t=e.generateVariable(this.varName);return this.options.formatter&&this.generateFormatter(e,t,this.options.formatter),this.generateNext(e)},e.prototype.generateAssert=function(e){if(this.options.assert){var t=e.generateVariable(this.varName);switch(typeof this.options.assert){case"function":var r=e.addImport(this.options.assert);e.pushCode("if (!"+r+".call(vars, "+t+")) {");break;case"number":e.pushCode("if ("+this.options.assert+" !== "+t+") {");break;case"string":e.pushCode('if ("'+this.options.assert+'" !== '+t+") {");break;default:throw new Error("Assert option supports only strings, numbers and assert functions.")}e.generateError('"Assert error: '+t+' is " + '+this.options.assert),e.pushCode("}")}},e.prototype.generateNext=function(e){return this.next&&(e=this.next.generate(e)),e},e.prototype.generateBit=function(e){var t=JSON.parse(JSON.stringify(this));if(t.varName=e.generateVariable(t.varName),e.bitFields.push(t),!this.next||this.next&&["bit","nest"].indexOf(this.next.type)<0){var r=0;e.bitFields.forEach((function(e){return r+=e.options.length}));var p=e.generateTmpVariable();if(r<=8)e.pushCode("var "+p+" = dataView.getUint8(offset);"),r=8;else if(r<=16)e.pushCode("var "+p+" = dataView.getUint16(offset);"),r=16;else if(r<=24){var o=e.generateTmpVariable(),i=e.generateTmpVariable();e.pushCode("var "+o+" = dataView.getUint16(offset);"),e.pushCode("var "+i+" = dataView.getUint8(offset + 2);"),e.pushCode("var "+p+" = ("+o+" << 8) | "+i+";"),r=24}else{if(!(r<=32))throw new Error("Currently, bit field sequence longer than 4-bytes is not supported.");e.pushCode("var "+p+" = dataView.getUint32(offset);"),r=32}e.pushCode("offset += "+r/8+";");var s=0,n="be"===this.endian;e.bitFields.forEach((function(t){var o=t.options.length,i=n?r-s-o:s,a=(1<> "+i+" & "+a+";"),s+=o})),e.bitFields=[]}},e.prototype.generateSeek=function(e){var t=e.generateOption(this.options.length);e.pushCode("offset += "+t+";")},e.prototype.generateString=function(e){var t=e.generateVariable(this.varName),r=e.generateTmpVariable(),p=this.options.encoding,o="hex"===p.toLowerCase(),i='b => b.toString(16).padStart(2, "0")';if(this.options.length&&this.options.zeroTerminated){var s=this.options.length;e.pushCode("var "+r+" = offset;"),e.pushCode("while(dataView.getUint8(offset++) !== 0 && offset - "+r+" < "+s+");");var n="offset - "+r+" < "+s+" ? offset - 1 : offset";e.pushCode(o?t+" = Array.from(buffer.subarray("+r+", "+n+"), "+i+").join('');":t+" = new TextDecoder('"+p+"').decode(buffer.subarray("+r+", "+n+"));")}else if(this.options.length){s=e.generateOption(this.options.length);e.pushCode(o?t+" = Array.from(buffer.subarray(offset, offset + "+s+"), "+i+").join('');":t+" = new TextDecoder('"+p+"').decode(buffer.subarray(offset, offset + "+s+"));"),e.pushCode("offset += "+s+";")}else this.options.zeroTerminated?(e.pushCode("var "+r+" = offset;"),e.pushCode("while(dataView.getUint8(offset++) !== 0);"),e.pushCode(o?t+" = Array.from(buffer.subarray("+r+", offset - 1)), "+i+").join('');":t+" = new TextDecoder('"+p+"').decode(buffer.subarray("+r+", offset - 1));")):this.options.greedy&&(e.pushCode("var "+r+" = offset;"),e.pushCode("while(buffer.length > offset++);"),e.pushCode(o?t+" = Array.from(buffer.subarray("+r+", offset)), "+i+").join('');":t+" = new TextDecoder('"+p+"').decode(buffer.subarray("+r+", offset));"));this.options.stripNull&&e.pushCode(t+" = "+t+".replace(/\\x00+$/g, '')")},e.prototype.generateBuffer=function(e){var t=e.generateVariable(this.varName);if("function"==typeof this.options.readUntil){var r=this.options.readUntil,p=e.generateTmpVariable(),o=e.generateTmpVariable();e.pushCode("var "+p+" = offset;"),e.pushCode("var "+o+" = 0;"),e.pushCode("while (offset < buffer.length) {"),e.pushCode(o+" = dataView.getUint8(offset);");var i=e.addImport(r);e.pushCode("if ("+i+".call(this, "+o+", buffer.subarray(offset))) break;"),e.pushCode("offset += 1;"),e.pushCode("}"),e.pushCode(t+" = buffer.subarray("+p+", offset);")}else if("eof"===this.options.readUntil)e.pushCode(t+" = buffer.subarray(offset);");else{var s=e.generateOption(this.options.length);e.pushCode(t+" = buffer.subarray(offset, offset + "+s+");"),e.pushCode("offset += "+s+";")}this.options.clone&&e.pushCode(t+" = buffer.constructor.from("+t+");")},e.prototype.generateArray=function(t){var r=t.generateOption(this.options.length),p=t.generateOption(this.options.lengthInBytes),a=this.options.type,l=t.generateTmpVariable(),c=t.generateVariable(this.varName),u=t.generateTmpVariable(),y=this.options.key,h="string"==typeof y;if(h?t.pushCode(c+" = {};"):t.pushCode(c+" = [];"),"function"==typeof this.options.readUntil?t.pushCode("do {"):"eof"===this.options.readUntil?t.pushCode("for (var "+l+" = 0; offset < buffer.length; "+l+"++) {"):void 0!==p?t.pushCode("for (var "+l+" = offset + "+p+"; offset < "+l+"; ) {"):t.pushCode("for (var "+l+" = "+r+"; "+l+" > 0; "+l+"--) {"),"string"==typeof a)if(o[a]){var f=t.generateTmpVariable();t.pushCode("var "+f+" = ___parser_"+a+"(offset);"),t.pushCode("var "+u+" = "+f+".result; offset = "+f+".offset;"),a!==this.alias&&t.addReference(a)}else{var d=s[a],_=n[a];t.pushCode("var "+u+" = dataView.get"+d+"(offset, "+_+");"),t.pushCode("offset += "+i[a]+";")}else a instanceof e&&(t.pushCode("var "+u+" = {};"),t.pushScope(u),a.generate(t),t.popScope());if(h?t.pushCode(c+"["+u+"."+y+"] = "+u+";"):t.pushCode(c+".push("+u+");"),t.pushCode("}"),"function"==typeof this.options.readUntil){var S=this.options.readUntil,g=t.addImport(S);t.pushCode("while (!"+g+".call(this, "+u+", buffer.subarray(offset)));")}},e.prototype.generateChoiceCase=function(t,r,p){if("string"==typeof p){var a=t.generateVariable(this.varName);if(o[p]){var l=t.generateTmpVariable();t.pushCode("var "+l+" = ___parser_"+p+"(offset);"),t.pushCode(a+" = "+l+".result; offset = "+l+".offset;"),p!==this.alias&&t.addReference(p)}else{var c=s[p],u=n[p];t.pushCode(a+" = dataView.get"+c+"(offset, "+u+");"),t.pushCode("offset += "+i[p])}}else p instanceof e&&(t.pushPath(r),p.generate(t),t.popPath(r))},e.prototype.generateChoice=function(e){var t=this,r=e.generateOption(this.options.tag);this.varName&&e.pushCode(e.generateVariable(this.varName)+" = {};"),e.pushCode("switch("+r+") {"),Object.keys(this.options.choices).forEach((function(r){var p=t.options.choices[parseInt(r,10)];e.pushCode("case "+r+":"),t.generateChoiceCase(e,t.varName,p),e.pushCode("break;")})),e.pushCode("default:"),this.options.defaultChoice?this.generateChoiceCase(e,this.varName,this.options.defaultChoice):e.generateError('"Met undefined tag value " + '+r+' + " at choice"'),e.pushCode("}")},e.prototype.generateNest=function(t){var r=t.generateVariable(this.varName);if(this.options.type instanceof e)this.varName&&t.pushCode(r+" = {};"),t.pushPath(this.varName),this.options.type.generate(t),t.popPath(this.varName);else if(o[this.options.type]){var p=t.generateTmpVariable();t.pushCode("var "+p+" = ___parser_"+this.options.type+"(offset);"),t.pushCode(r+" = "+p+".result; offset = "+p+".offset;"),this.options.type!==this.alias&&t.addReference(this.options.type)}},e.prototype.generateFormatter=function(e,t,r){if("function"==typeof r){var p=e.addImport(r);e.pushCode(t+" = "+p+".call(this, "+t+");")}},e.prototype.generatePointer=function(t){var r=this.options.type,p=t.generateOption(this.options.offset),a=t.generateTmpVariable(),l=t.generateVariable(this.varName);if(t.pushCode("var "+a+" = offset;"),t.pushCode("offset = "+p+";"),this.options.type instanceof e)t.pushCode(l+" = {};"),t.pushPath(this.varName),this.options.type.generate(t),t.popPath(this.varName);else if(o[this.options.type]){var c=t.generateTmpVariable();t.pushCode("var "+c+" = ___parser_"+this.options.type+"(offset);"),t.pushCode(l+" = "+c+".result; offset = "+c+".offset;"),this.options.type!==this.alias&&t.addReference(this.options.type)}else if(Object.keys(i).indexOf(this.options.type)>=0){var u=s[r],y=n[r];t.pushCode(l+" = dataView.get"+u+"(offset, "+y+");"),t.pushCode("offset += "+i[r]+";")}t.pushCode("offset = "+a+";")},e.prototype.generateSaveOffset=function(e){var t=e.generateVariable(this.varName);e.pushCode(t+" = offset")},e}();t.Parser=a},function(e,t,r){(function(e,p){var o=/%[sdj%]/g;t.format=function(e){if(!S(e)){for(var t=[],r=0;r=i)return e;switch(e){case"%s":return String(p[r++]);case"%d":return Number(p[r++]);case"%j":try{return JSON.stringify(p[r++])}catch(e){return"[Circular]"}default:return e}})),a=p[r];r=3&&(p.depth=arguments[2]),arguments.length>=4&&(p.colors=arguments[3]),f(r)?p.showHidden=r:r&&t._extend(p,r),g(p.showHidden)&&(p.showHidden=!1),g(p.depth)&&(p.depth=2),g(p.colors)&&(p.colors=!1),g(p.customInspect)&&(p.customInspect=!0),p.colors&&(p.stylize=a),c(p,e,p.depth)}function a(e,t){var r=n.styles[t];return r?"["+n.colors[r][0]+"m"+e+"["+n.colors[r][1]+"m":e}function l(e,t){return e}function c(e,r,p){if(e.customInspect&&r&&v(r.inspect)&&r.inspect!==t.inspect&&(!r.constructor||r.constructor.prototype!==r)){var o=r.inspect(p,e);return S(o)||(o=c(e,o,p)),o}var i=function(e,t){if(g(t))return e.stylize("undefined","undefined");if(S(t)){var r="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(r,"string")}if(_(t))return e.stylize(""+t,"number");if(f(t))return e.stylize(""+t,"boolean");if(d(t))return e.stylize("null","null")}(e,r);if(i)return i;var s=Object.keys(r),n=function(e){var t={};return e.forEach((function(e,r){t[e]=!0})),t}(s);if(e.showHidden&&(s=Object.getOwnPropertyNames(r)),b(r)&&(s.indexOf("message")>=0||s.indexOf("description")>=0))return u(r);if(0===s.length){if(v(r)){var a=r.name?": "+r.name:"";return e.stylize("[Function"+a+"]","special")}if(w(r))return e.stylize(RegExp.prototype.toString.call(r),"regexp");if(m(r))return e.stylize(Date.prototype.toString.call(r),"date");if(b(r))return u(r)}var l,E="",I=!1,L=["{","}"];(h(r)&&(I=!0,L=["[","]"]),v(r))&&(E=" [Function"+(r.name?": "+r.name:"")+"]");return w(r)&&(E=" "+RegExp.prototype.toString.call(r)),m(r)&&(E=" "+Date.prototype.toUTCString.call(r)),b(r)&&(E=" "+u(r)),0!==s.length||I&&0!=r.length?p<0?w(r)?e.stylize(RegExp.prototype.toString.call(r),"regexp"):e.stylize("[Object]","special"):(e.seen.push(r),l=I?function(e,t,r,p,o){for(var i=[],s=0,n=t.length;s=0&&0,e+t.replace(/\u001b\[\d\d?m/g,"").length+1}),0)>60)return r[0]+(""===t?"":t+"\n ")+" "+e.join(",\n ")+" "+r[1];return r[0]+t+" "+e.join(", ")+" "+r[1]}(l,E,L)):L[0]+E+L[1]}function u(e){return"["+Error.prototype.toString.call(e)+"]"}function y(e,t,r,p,o,i){var s,n,a;if((a=Object.getOwnPropertyDescriptor(t,o)||{value:t[o]}).get?n=a.set?e.stylize("[Getter/Setter]","special"):e.stylize("[Getter]","special"):a.set&&(n=e.stylize("[Setter]","special")),M(p,o)||(s="["+o+"]"),n||(e.seen.indexOf(a.value)<0?(n=d(r)?c(e,a.value,null):c(e,a.value,r-1)).indexOf("\n")>-1&&(n=i?n.split("\n").map((function(e){return" "+e})).join("\n").substr(2):"\n"+n.split("\n").map((function(e){return" "+e})).join("\n")):n=e.stylize("[Circular]","special")),g(s)){if(i&&o.match(/^\d+$/))return n;(s=JSON.stringify(""+o)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(s=s.substr(1,s.length-2),s=e.stylize(s,"name")):(s=s.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),s=e.stylize(s,"string"))}return s+": "+n}function h(e){return Array.isArray(e)}function f(e){return"boolean"==typeof e}function d(e){return null===e}function _(e){return"number"==typeof e}function S(e){return"string"==typeof e}function g(e){return void 0===e}function w(e){return E(e)&&"[object RegExp]"===I(e)}function E(e){return"object"==typeof e&&null!==e}function m(e){return E(e)&&"[object Date]"===I(e)}function b(e){return E(e)&&("[object Error]"===I(e)||e instanceof Error)}function v(e){return"function"==typeof e}function I(e){return Object.prototype.toString.call(e)}function L(e){return e<10?"0"+e.toString(10):e.toString(10)}t.debuglog=function(e){if(g(i)&&(i=p.env.NODE_DEBUG||""),e=e.toUpperCase(),!s[e])if(new RegExp("\\b"+e+"\\b","i").test(i)){var r=p.pid;s[e]=function(){var p=t.format.apply(t,arguments);console.error("%s %d: %s",e,r,p)}}else s[e]=function(){};return s[e]},t.inspect=n,n.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},n.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"},t.isArray=h,t.isBoolean=f,t.isNull=d,t.isNullOrUndefined=function(e){return null==e},t.isNumber=_,t.isString=S,t.isSymbol=function(e){return"symbol"==typeof e},t.isUndefined=g,t.isRegExp=w,t.isObject=E,t.isDate=m,t.isError=b,t.isFunction=v,t.isPrimitive=function(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||void 0===e},t.isBuffer=r(29);var T=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];function U(){var e=new Date,t=[L(e.getHours()),L(e.getMinutes()),L(e.getSeconds())].join(":");return[e.getDate(),T[e.getMonth()],t].join(" ")}function M(e,t){return Object.prototype.hasOwnProperty.call(e,t)}t.log=function(){console.log("%s - %s",U(),t.format.apply(t,arguments))},t.inherits=r(6),t._extend=function(e,t){if(!t||!E(t))return e;for(var r=Object.keys(t),p=r.length;p--;)e[r[p]]=t[r[p]];return e}}).call(this,r(5),r(9))},function(e,t,r){"use strict";(function(t,p){var o=r(11);e.exports=w;var i,s=r(16);w.ReadableState=g;r(13).EventEmitter;var n=function(e,t){return e.listeners(t).length},a=r(20),l=r(12).Buffer,c=t.Uint8Array||function(){};var u=r(10);u.inherits=r(6);var y=r(32),h=void 0;h=y&&y.debuglog?y.debuglog("stream"):function(){};var f,d=r(33),_=r(21);u.inherits(w,a);var S=["error","close","destroy","pause","resume"];function g(e,t){e=e||{};var p=t instanceof(i=i||r(7));this.objectMode=!!e.objectMode,p&&(this.objectMode=this.objectMode||!!e.readableObjectMode);var o=e.highWaterMark,s=e.readableHighWaterMark,n=this.objectMode?16:16384;this.highWaterMark=o||0===o?o:p&&(s||0===s)?s:n,this.highWaterMark=Math.floor(this.highWaterMark),this.buffer=new d,this.length=0,this.pipes=null,this.pipesCount=0,this.flowing=null,this.ended=!1,this.endEmitted=!1,this.reading=!1,this.sync=!0,this.needReadable=!1,this.emittedReadable=!1,this.readableListening=!1,this.resumeScheduled=!1,this.destroyed=!1,this.defaultEncoding=e.defaultEncoding||"utf8",this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,e.encoding&&(f||(f=r(22).StringDecoder),this.decoder=new f(e.encoding),this.encoding=e.encoding)}function w(e){if(i=i||r(7),!(this instanceof w))return new w(e);this._readableState=new g(e,this),this.readable=!0,e&&("function"==typeof e.read&&(this._read=e.read),"function"==typeof e.destroy&&(this._destroy=e.destroy)),a.call(this)}function E(e,t,r,p,o){var i,s=e._readableState;null===t?(s.reading=!1,function(e,t){if(t.ended)return;if(t.decoder){var r=t.decoder.end();r&&r.length&&(t.buffer.push(r),t.length+=t.objectMode?1:r.length)}t.ended=!0,v(e)}(e,s)):(o||(i=function(e,t){var r;p=t,l.isBuffer(p)||p instanceof c||"string"==typeof t||void 0===t||e.objectMode||(r=new TypeError("Invalid non-string/buffer chunk"));var p;return r}(s,t)),i?e.emit("error",i):s.objectMode||t&&t.length>0?("string"==typeof t||s.objectMode||Object.getPrototypeOf(t)===l.prototype||(t=function(e){return l.from(e)}(t)),p?s.endEmitted?e.emit("error",new Error("stream.unshift() after end event")):m(e,s,t,!0):s.ended?e.emit("error",new Error("stream.push() after EOF")):(s.reading=!1,s.decoder&&!r?(t=s.decoder.write(t),s.objectMode||0!==t.length?m(e,s,t,!1):L(e,s)):m(e,s,t,!1))):p||(s.reading=!1));return function(e){return!e.ended&&(e.needReadable||e.lengtht.highWaterMark&&(t.highWaterMark=function(e){return e>=8388608?e=8388608:(e--,e|=e>>>1,e|=e>>>2,e|=e>>>4,e|=e>>>8,e|=e>>>16,e++),e}(e)),e<=t.length?e:t.ended?t.length:(t.needReadable=!0,0))}function v(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(h("emitReadable",t.flowing),t.emittedReadable=!0,t.sync?o.nextTick(I,e):I(e))}function I(e){h("emit readable"),e.emit("readable"),D(e)}function L(e,t){t.readingMore||(t.readingMore=!0,o.nextTick(T,e,t))}function T(e,t){for(var r=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length=t.length?(r=t.decoder?t.buffer.join(""):1===t.buffer.length?t.buffer.head.data:t.buffer.concat(t.length),t.buffer.clear()):r=function(e,t,r){var p;ei.length?i.length:e;if(s===i.length?o+=i:o+=i.slice(0,e),0===(e-=s)){s===i.length?(++p,r.next?t.head=r.next:t.head=t.tail=null):(t.head=r,r.data=i.slice(s));break}++p}return t.length-=p,o}(e,t):function(e,t){var r=l.allocUnsafe(e),p=t.head,o=1;p.data.copy(r),e-=p.data.length;for(;p=p.next;){var i=p.data,s=e>i.length?i.length:e;if(i.copy(r,r.length-e,0,s),0===(e-=s)){s===i.length?(++o,p.next?t.head=p.next:t.head=t.tail=null):(t.head=p,p.data=i.slice(s));break}++o}return t.length-=o,r}(e,t);return p}(e,t.buffer,t.decoder),r);var r}function G(e){var t=e._readableState;if(t.length>0)throw new Error('"endReadable()" called on non-empty stream');t.endEmitted||(t.ended=!0,o.nextTick(A,t,e))}function A(e,t){e.endEmitted||0!==e.length||(e.endEmitted=!0,t.readable=!1,t.emit("end"))}function C(e,t){for(var r=0,p=e.length;r=t.highWaterMark||t.ended))return h("read: emitReadable",t.length,t.ended),0===t.length&&t.ended?G(this):v(this),null;if(0===(e=b(e,t))&&t.ended)return 0===t.length&&G(this),null;var p,o=t.needReadable;return h("need readable",o),(0===t.length||t.length-e0?O(e,t):null)?(t.needReadable=!0,e=0):t.length-=e,0===t.length&&(t.ended||(t.needReadable=!0),r!==e&&t.ended&&G(this)),null!==p&&this.emit("data",p),p},w.prototype._read=function(e){this.emit("error",new Error("_read() is not implemented"))},w.prototype.pipe=function(e,t){var r=this,i=this._readableState;switch(i.pipesCount){case 0:i.pipes=e;break;case 1:i.pipes=[i.pipes,e];break;default:i.pipes.push(e)}i.pipesCount+=1,h("pipe count=%d opts=%j",i.pipesCount,t);var a=(!t||!1!==t.end)&&e!==p.stdout&&e!==p.stderr?c:w;function l(t,p){h("onunpipe"),t===r&&p&&!1===p.hasUnpiped&&(p.hasUnpiped=!0,h("cleanup"),e.removeListener("close",S),e.removeListener("finish",g),e.removeListener("drain",u),e.removeListener("error",_),e.removeListener("unpipe",l),r.removeListener("end",c),r.removeListener("end",w),r.removeListener("data",d),y=!0,!i.awaitDrain||e._writableState&&!e._writableState.needDrain||u())}function c(){h("onend"),e.end()}i.endEmitted?o.nextTick(a):r.once("end",a),e.on("unpipe",l);var u=function(e){return function(){var t=e._readableState;h("pipeOnDrain",t.awaitDrain),t.awaitDrain&&t.awaitDrain--,0===t.awaitDrain&&n(e,"data")&&(t.flowing=!0,D(e))}}(r);e.on("drain",u);var y=!1;var f=!1;function d(t){h("ondata"),f=!1,!1!==e.write(t)||f||((1===i.pipesCount&&i.pipes===e||i.pipesCount>1&&-1!==C(i.pipes,e))&&!y&&(h("false write response, pause",r._readableState.awaitDrain),r._readableState.awaitDrain++,f=!0),r.pause())}function _(t){h("onerror",t),w(),e.removeListener("error",_),0===n(e,"error")&&e.emit("error",t)}function S(){e.removeListener("finish",g),w()}function g(){h("onfinish"),e.removeListener("close",S),w()}function w(){h("unpipe"),r.unpipe(e)}return r.on("data",d),function(e,t,r){if("function"==typeof e.prependListener)return e.prependListener(t,r);e._events&&e._events[t]?s(e._events[t])?e._events[t].unshift(r):e._events[t]=[r,e._events[t]]:e.on(t,r)}(e,"error",_),e.once("close",S),e.once("finish",g),e.emit("pipe",r),i.flowing||(h("pipe resume"),r.resume()),e},w.prototype.unpipe=function(e){var t=this._readableState,r={hasUnpiped:!1};if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes||(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,t.flowing=!1,e&&e.emit("unpipe",this,r)),this;if(!e){var p=t.pipes,o=t.pipesCount;t.pipes=null,t.pipesCount=0,t.flowing=!1;for(var i=0;i>5==6?2:e>>4==14?3:e>>3==30?4:e>>6==2?-1:-2}function n(e){var t=this.lastTotal-this.lastNeed,r=function(e,t,r){if(128!=(192&t[0]))return e.lastNeed=0,"�";if(e.lastNeed>1&&t.length>1){if(128!=(192&t[1]))return e.lastNeed=1,"�";if(e.lastNeed>2&&t.length>2&&128!=(192&t[2]))return e.lastNeed=2,"�"}}(this,e);return void 0!==r?r:this.lastNeed<=e.length?(e.copy(this.lastChar,t,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal)):(e.copy(this.lastChar,t,0,e.length),void(this.lastNeed-=e.length))}function a(e,t){if((e.length-t)%2==0){var r=e.toString("utf16le",t);if(r){var p=r.charCodeAt(r.length-1);if(p>=55296&&p<=56319)return this.lastNeed=2,this.lastTotal=4,this.lastChar[0]=e[e.length-2],this.lastChar[1]=e[e.length-1],r.slice(0,-1)}return r}return this.lastNeed=1,this.lastTotal=2,this.lastChar[0]=e[e.length-1],e.toString("utf16le",t,e.length-1)}function l(e){var t=e&&e.length?this.write(e):"";if(this.lastNeed){var r=this.lastTotal-this.lastNeed;return t+this.lastChar.toString("utf16le",0,r)}return t}function c(e,t){var r=(e.length-t)%3;return 0===r?e.toString("base64",t):(this.lastNeed=3-r,this.lastTotal=3,1===r?this.lastChar[0]=e[e.length-1]:(this.lastChar[0]=e[e.length-2],this.lastChar[1]=e[e.length-1]),e.toString("base64",t,e.length-r))}function u(e){var t=e&&e.length?this.write(e):"";return this.lastNeed?t+this.lastChar.toString("base64",0,3-this.lastNeed):t}function y(e){return e.toString(this.encoding)}function h(e){return e&&e.length?this.write(e):""}t.StringDecoder=i,i.prototype.write=function(e){if(0===e.length)return"";var t,r;if(this.lastNeed){if(void 0===(t=this.fillLast(e)))return"";r=this.lastNeed,this.lastNeed=0}else r=0;return r=0)return o>0&&(e.lastNeed=o-1),o;if(--p=0)return o>0&&(e.lastNeed=o-2),o;if(--p=0)return o>0&&(2===o?o=0:e.lastNeed=o-3),o;return 0}(this,e,t);if(!this.lastNeed)return e.toString("utf8",t);this.lastTotal=r;var p=e.length-(r-this.lastNeed);return e.copy(this.lastChar,0,p),e.toString("utf8",t,p)},i.prototype.fillLast=function(e){if(this.lastNeed<=e.length)return e.copy(this.lastChar,this.lastTotal-this.lastNeed,0,this.lastNeed),this.lastChar.toString(this.encoding,0,this.lastTotal);e.copy(this.lastChar,this.lastTotal-this.lastNeed,0,e.length),this.lastNeed-=e.length}},function(e,t,r){"use strict";e.exports=s;var p=r(7),o=r(10);function i(e,t){var r=this._transformState;r.transforming=!1;var p=r.writecb;if(!p)return this.emit("error",new Error("write callback called multiple times"));r.writechunk=null,r.writecb=null,null!=t&&this.push(t),p(e);var o=this._readableState;o.reading=!1,(o.needReadable||o.length>8&255^255&r],t&=65535;return t}p.exports={preambleByte:85,crc16:S,sbpIdTable:h,sbpMessageTypesTable:f,decode:function(e){var t=d.parse(e),r=h[t.msg_type];return void 0===r?(console.log("Unknown message type: ",t.msg_type),new s(t)):new r(t)},dispatch:function(t,r,o){var i,s,n=new e(0);if(void 0===o&&"function"==typeof r?i=r:(i=o,s=r),s&&!Array.isArray(s)&&-1===["function","number"].indexOf(typeof s))throw l("dispatch: messageWhitelist must be function, number, or array");var a=function(r){t.pause();try{if((n=e.concat([n,r])).length<2)return;var o=function(){var e,t,r,o,i,a,l;for(l=0;ln.length)throw new c;e=n.slice(l+1,l+6),r=n.readUInt16LE(l+1),_=n.readUInt16LE(l+3),o=n.readUInt8(l+5);var y=s&&Array.isArray(s)&&-1!==s.indexOf(r),h=s&&"number"==typeof s&&s&r,f=s&&"function"==typeof s&&s(r);if(s&&!(y||h||f))return n=n.slice(l+6+o+2),null;if(l+8+o>n.length)throw new c;a=S(n.slice(l+6,l+6+o),S(e)),i=n.readUInt16LE(l+6+o);var d=n.slice(l,l+6+o+2);if(i===a)return n=n.slice(l+6+o+2),[p.exports.decode(d),d];throw n=n.slice(l+1),new u}();if(null===o)return;var l=o[0],y=o[1];i(null,l,y)}catch(e){if(!(e instanceof c||e instanceof u))throw e}finally{t.resume(),n.length>0&&setTimeout((function(){a(new e(0))}),0)}};t.on("data",a)}},function(e){var r={function:!0,object:!0},i=r[typeof window]&&window||this,s=r[typeof t]&&t&&!t.nodeType&&t,n=r[typeof p]&&p&&!p.nodeType&&p,a=s&&n&&"object"==typeof o&&o;!a||a.global!==a&&a.window!==a&&a.self!==a||(i=a),i.SBP=e}(p.exports)}).call(this,r(8).Buffer,r(27)(e),r(5))},function(e,t,r){"use strict";t.byteLength=function(e){var t=l(e),r=t[0],p=t[1];return 3*(r+p)/4-p},t.toByteArray=function(e){for(var t,r=l(e),p=r[0],s=r[1],n=new i(function(e,t,r){return 3*(t+r)/4-r}(0,p,s)),a=0,c=s>0?p-4:p,u=0;u>16&255,n[a++]=t>>8&255,n[a++]=255&t;2===s&&(t=o[e.charCodeAt(u)]<<2|o[e.charCodeAt(u+1)]>>4,n[a++]=255&t);1===s&&(t=o[e.charCodeAt(u)]<<10|o[e.charCodeAt(u+1)]<<4|o[e.charCodeAt(u+2)]>>2,n[a++]=t>>8&255,n[a++]=255&t);return n},t.fromByteArray=function(e){for(var t,r=e.length,o=r%3,i=[],s=0,n=r-o;sn?n:s+16383));1===o?(t=e[r-1],i.push(p[t>>2]+p[t<<4&63]+"==")):2===o&&(t=(e[r-2]<<8)+e[r-1],i.push(p[t>>10]+p[t>>4&63]+p[t<<2&63]+"="));return i.join("")};for(var p=[],o=[],i="undefined"!=typeof Uint8Array?Uint8Array:Array,s="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",n=0,a=s.length;n0)throw new Error("Invalid string. Length must be a multiple of 4");var r=e.indexOf("=");return-1===r&&(r=t),[r,r===t?0:4-r%4]}function c(e,t,r){for(var o,i,s=[],n=t;n>18&63]+p[i>>12&63]+p[i>>6&63]+p[63&i]);return s.join("")}o["-".charCodeAt(0)]=62,o["_".charCodeAt(0)]=63},function(e,t){t.read=function(e,t,r,p,o){var i,s,n=8*o-p-1,a=(1<>1,c=-7,u=r?o-1:0,y=r?-1:1,h=e[t+u];for(u+=y,i=h&(1<<-c)-1,h>>=-c,c+=n;c>0;i=256*i+e[t+u],u+=y,c-=8);for(s=i&(1<<-c)-1,i>>=-c,c+=p;c>0;s=256*s+e[t+u],u+=y,c-=8);if(0===i)i=1-l;else{if(i===a)return s?NaN:1/0*(h?-1:1);s+=Math.pow(2,p),i-=l}return(h?-1:1)*s*Math.pow(2,i-p)},t.write=function(e,t,r,p,o,i){var s,n,a,l=8*i-o-1,c=(1<>1,y=23===o?Math.pow(2,-24)-Math.pow(2,-77):0,h=p?0:i-1,f=p?1:-1,d=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(n=isNaN(t)?1:0,s=c):(s=Math.floor(Math.log(t)/Math.LN2),t*(a=Math.pow(2,-s))<1&&(s--,a*=2),(t+=s+u>=1?y/a:y*Math.pow(2,1-u))*a>=2&&(s++,a/=2),s+u>=c?(n=0,s=c):s+u>=1?(n=(t*a-1)*Math.pow(2,o),s+=u):(n=t*Math.pow(2,u-1)*Math.pow(2,o),s=0));o>=8;e[r+h]=255&n,h+=f,n/=256,o-=8);for(s=s<0;e[r+h]=255&s,h+=f,s/=256,l-=8);e[r+h-f]|=128*d}},function(e,t){e.exports=function(e){return e.webpackPolyfill||(e.deprecate=function(){},e.paths=[],e.children||(e.children=[]),Object.defineProperty(e,"loaded",{enumerable:!0,get:function(){return e.l}}),Object.defineProperty(e,"id",{enumerable:!0,get:function(){return e.i}}),e.webpackPolyfill=1),e}},function(e,t,r){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.Context=void 0;var p=function(){function e(e){this.code="",this.scopes=[["vars"]],this.bitFields=[],this.tmpVariableCount=0,this.references={},this.imports=[],this.reverseImports=new Map,this.importPath=e}return e.prototype.generateVariable=function(e){var t=[],r=this.scopes[this.scopes.length-1];return t.push.apply(t,r),e&&t.push(e),t.join(".")},e.prototype.generateOption=function(e){switch(typeof e){case"number":return e.toString();case"string":return this.generateVariable(e);case"function":return this.addImport(e)+".call("+this.generateVariable()+", vars)"}},e.prototype.generateError=function(e){this.pushCode("throw new Error("+e+");")},e.prototype.generateTmpVariable=function(){return"$tmp"+this.tmpVariableCount++},e.prototype.pushCode=function(e){this.code+=e+"\n"},e.prototype.pushPath=function(e){e&&this.scopes[this.scopes.length-1].push(e)},e.prototype.popPath=function(e){e&&this.scopes[this.scopes.length-1].pop()},e.prototype.pushScope=function(e){this.scopes.push([e])},e.prototype.popScope=function(){this.scopes.pop()},e.prototype.addImport=function(e){if(!this.importPath)return"("+e+")";var t=this.reverseImports.get(e);return t||(t=this.imports.push(e)-1,this.reverseImports.set(e,t)),this.importPath+"["+t+"]"},e.prototype.addReference=function(e){this.references[e]||(this.references[e]={resolved:!1,requested:!1})},e.prototype.markResolved=function(e){this.references[e].resolved=!0},e.prototype.markRequested=function(e){var t=this;e.forEach((function(e){t.references[e].requested=!0}))},e.prototype.getUnresolvedReferences=function(){var e=this.references;return Object.keys(this.references).filter((function(t){return!e[t].resolved&&!e[t].requested}))},e}();t.Context=p},function(e,t){e.exports=function(e){return e&&"object"==typeof e&&"function"==typeof e.copy&&"function"==typeof e.fill&&"function"==typeof e.readUInt8}},function(e,t,r){(function(e){function r(e,t){for(var r=0,p=e.length-1;p>=0;p--){var o=e[p];"."===o?e.splice(p,1):".."===o?(e.splice(p,1),r++):r&&(e.splice(p,1),r--)}if(t)for(;r--;r)e.unshift("..");return e}var p=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/,o=function(e){return p.exec(e).slice(1)};function i(e,t){if(e.filter)return e.filter(t);for(var r=[],p=0;p=-1&&!p;o--){var s=o>=0?arguments[o]:e.cwd();if("string"!=typeof s)throw new TypeError("Arguments to path.resolve must be strings");s&&(t=s+"/"+t,p="/"===s.charAt(0))}return(p?"/":"")+(t=r(i(t.split("/"),(function(e){return!!e})),!p).join("/"))||"."},t.normalize=function(e){var p=t.isAbsolute(e),o="/"===s(e,-1);return(e=r(i(e.split("/"),(function(e){return!!e})),!p).join("/"))||p||(e="."),e&&o&&(e+="/"),(p?"/":"")+e},t.isAbsolute=function(e){return"/"===e.charAt(0)},t.join=function(){var e=Array.prototype.slice.call(arguments,0);return t.normalize(i(e,(function(e,t){if("string"!=typeof e)throw new TypeError("Arguments to path.join must be strings");return e})).join("/"))},t.relative=function(e,r){function p(e){for(var t=0;t=0&&""===e[r];r--);return t>r?[]:e.slice(t,r-t+1)}e=t.resolve(e).substr(1),r=t.resolve(r).substr(1);for(var o=p(e.split("/")),i=p(r.split("/")),s=Math.min(o.length,i.length),n=s,a=0;a0?this.tail.next=t:this.head=t,this.tail=t,++this.length},e.prototype.unshift=function(e){var t={data:e,next:this.head};0===this.length&&(this.tail=t),this.head=t,++this.length},e.prototype.shift=function(){if(0!==this.length){var e=this.head.data;return 1===this.length?this.head=this.tail=null:this.head=this.head.next,--this.length,e}},e.prototype.clear=function(){this.head=this.tail=null,this.length=0},e.prototype.join=function(e){if(0===this.length)return"";for(var t=this.head,r=""+t.data;t=t.next;)r+=e+t.data;return r},e.prototype.concat=function(e){if(0===this.length)return p.alloc(0);if(1===this.length)return this.head.data;for(var t=p.allocUnsafe(e>>>0),r=this.head,o=0;r;)i(r.data,t,o),o+=r.data.length,r=r.next;return t},e}(),o&&o.inspect&&o.inspect.custom&&(e.exports.prototype[o.inspect.custom]=function(){var e=o.inspect({length:this.length});return this.constructor.name+" "+e})},function(e,t){},function(e,t,r){(function(e){var p=void 0!==e&&e||"undefined"!=typeof self&&self||window,o=Function.prototype.apply;function i(e,t){this._id=e,this._clearFn=t}t.setTimeout=function(){return new i(o.call(setTimeout,p,arguments),clearTimeout)},t.setInterval=function(){return new i(o.call(setInterval,p,arguments),clearInterval)},t.clearTimeout=t.clearInterval=function(e){e&&e.close()},i.prototype.unref=i.prototype.ref=function(){},i.prototype.close=function(){this._clearFn.call(p,this._id)},t.enroll=function(e,t){clearTimeout(e._idleTimeoutId),e._idleTimeout=t},t.unenroll=function(e){clearTimeout(e._idleTimeoutId),e._idleTimeout=-1},t._unrefActive=t.active=function(e){clearTimeout(e._idleTimeoutId);var t=e._idleTimeout;t>=0&&(e._idleTimeoutId=setTimeout((function(){e._onTimeout&&e._onTimeout()}),t))},r(36),t.setImmediate="undefined"!=typeof self&&self.setImmediate||void 0!==e&&e.setImmediate||this&&this.setImmediate,t.clearImmediate="undefined"!=typeof self&&self.clearImmediate||void 0!==e&&e.clearImmediate||this&&this.clearImmediate}).call(this,r(5))},function(e,t,r){(function(e,t){!function(e,r){"use strict";if(!e.setImmediate){var p,o,i,s,n,a=1,l={},c=!1,u=e.document,y=Object.getPrototypeOf&&Object.getPrototypeOf(e);y=y&&y.setTimeout?y:e,"[object process]"==={}.toString.call(e.process)?p=function(e){t.nextTick((function(){f(e)}))}:!function(){if(e.postMessage&&!e.importScripts){var t=!0,r=e.onmessage;return e.onmessage=function(){t=!1},e.postMessage("","*"),e.onmessage=r,t}}()?e.MessageChannel?((i=new MessageChannel).port1.onmessage=function(e){f(e.data)},p=function(e){i.port2.postMessage(e)}):u&&"onreadystatechange"in u.createElement("script")?(o=u.documentElement,p=function(e){var t=u.createElement("script");t.onreadystatechange=function(){f(e),t.onreadystatechange=null,o.removeChild(t),t=null},o.appendChild(t)}):p=function(e){setTimeout(f,0,e)}:(s="setImmediate$"+Math.random()+"$",n=function(t){t.source===e&&"string"==typeof t.data&&0===t.data.indexOf(s)&&f(+t.data.slice(s.length))},e.addEventListener?e.addEventListener("message",n,!1):e.attachEvent("onmessage",n),p=function(t){e.postMessage(s+t,"*")}),y.setImmediate=function(e){"function"!=typeof e&&(e=new Function(""+e));for(var t=new Array(arguments.length-1),r=0;r * @license MIT */ -function p(e,t){if(e===t)return 0;for(var r=e.length,p=t.length,o=0,i=Math.min(r,p);o=0;l--)if(c[l]!==u[l])return!1;for(l=c.length-1;l>=0;l--)if(a=c[l],!g(e[a],t[a],r,p))return!1;return!0}(e,t,r,s))}return r?e===t:e==t}function w(e){return"[object Arguments]"==Object.prototype.toString.call(e)}function E(e,t){if(!e||!t)return!1;if("[object RegExp]"==Object.prototype.toString.call(t))return t.test(e);try{if(e instanceof t)return!0}catch(e){}return!Error.isPrototypeOf(t)&&!0===t.call({},e)}function m(e,t,r,p){var o;if("function"!=typeof t)throw new TypeError('"block" argument must be a function');"string"==typeof r&&(p=r,r=null),o=function(e){var t;try{e()}catch(e){t=e}return t}(t),p=(r&&r.name?" ("+r.name+").":".")+(p?" "+p:"."),e&&!o&&_(o,r,"Missing expected exception"+p);var s="string"==typeof p,n=!e&&o&&!r;if((!e&&i.isError(o)&&s&&E(o,r)||n)&&_(o,r,"Got unwanted exception"+p),e&&o&&r&&!E(o,r)||!e&&o)throw o}u.AssertionError=function(e){this.name="AssertionError",this.actual=e.actual,this.expected=e.expected,this.operator=e.operator,e.message?(this.message=e.message,this.generatedMessage=!1):(this.message=function(e){return f(d(e.actual),128)+" "+e.operator+" "+f(d(e.expected),128)}(this),this.generatedMessage=!0);var t=e.stackStartFunction||_;if(Error.captureStackTrace)Error.captureStackTrace(this,t);else{var r=new Error;if(r.stack){var p=r.stack,o=h(t),i=p.indexOf("\n"+o);if(i>=0){var s=p.indexOf("\n",i+1);p=p.substring(s+1)}this.stack=p}}},i.inherits(u.AssertionError,Error),u.fail=_,u.ok=S,u.equal=function(e,t,r){e!=t&&_(e,t,r,"==",u.equal)},u.notEqual=function(e,t,r){e==t&&_(e,t,r,"!=",u.notEqual)},u.deepEqual=function(e,t,r){g(e,t,!1)||_(e,t,r,"deepEqual",u.deepEqual)},u.deepStrictEqual=function(e,t,r){g(e,t,!0)||_(e,t,r,"deepStrictEqual",u.deepStrictEqual)},u.notDeepEqual=function(e,t,r){g(e,t,!1)&&_(e,t,r,"notDeepEqual",u.notDeepEqual)},u.notDeepStrictEqual=function e(t,r,p){g(t,r,!0)&&_(t,r,p,"notDeepStrictEqual",e)},u.strictEqual=function(e,t,r){e!==t&&_(e,t,r,"===",u.strictEqual)},u.notStrictEqual=function(e,t,r){e===t&&_(e,t,r,"!==",u.notStrictEqual)},u.throws=function(e,t,r){m(!0,e,t,r)},u.doesNotThrow=function(e,t,r){m(!1,e,t,r)},u.ifError=function(e){if(e)throw e};var b=Object.keys||function(e){var t=[];for(var r in e)s.call(e,r)&&t.push(r);return t}}).call(this,r(5))},function(e,t,r){var p;!function(r){o(Math.pow(36,5)),o(Math.pow(16,7)),o(Math.pow(10,9)),o(Math.pow(2,30)),o(36),o(16),o(10),o(2);function o(e,t){return this instanceof o?(this._low=0,this._high=0,this.remainder=null,void 0===t?s.call(this,e):"string"==typeof e?n.call(this,e,t):void i.call(this,e,t)):new o(e,t)}function i(e,t){return this._low=0|e,this._high=0|t,this}function s(e){return this._low=65535&e,this._high=e>>>16,this}function n(e,t){var r=parseInt(e,t||10);return this._low=65535&r,this._high=r>>>16,this}o.prototype.fromBits=i,o.prototype.fromNumber=s,o.prototype.fromString=n,o.prototype.toNumber=function(){return 65536*this._high+this._low},o.prototype.toString=function(e){return this.toNumber().toString(e||10)},o.prototype.add=function(e){var t=this._low+e._low,r=t>>>16;return r+=this._high+e._high,this._low=65535&t,this._high=65535&r,this},o.prototype.subtract=function(e){return this.add(e.clone().negate())},o.prototype.multiply=function(e){var t,r,p=this._high,o=this._low,i=e._high,s=e._low;return t=(r=o*s)>>>16,t+=p*s,t&=65535,t+=o*i,this._low=65535&r,this._high=65535&t,this},o.prototype.div=function(e){if(0==e._low&&0==e._high)throw Error("division by zero");if(0==e._high&&1==e._low)return this.remainder=new o(0),this;if(e.gt(this))return this.remainder=this.clone(),this._low=0,this._high=0,this;if(this.eq(e))return this.remainder=new o(0),this._low=1,this._high=0,this;for(var t=e.clone(),r=-1;!this.lt(t);)t.shiftLeft(1,!0),r++;for(this.remainder=this.clone(),this._low=0,this._high=0;r>=0;r--)t.shiftRight(1),this.remainder.lt(t)||(this.remainder.subtract(t),r>=16?this._high|=1<>>16)&65535,this},o.prototype.equals=o.prototype.eq=function(e){return this._low==e._low&&this._high==e._high},o.prototype.greaterThan=o.prototype.gt=function(e){return this._high>e._high||!(this._highe._low},o.prototype.lessThan=o.prototype.lt=function(e){return this._highe._high)&&this._low16?(this._low=this._high>>e-16,this._high=0):16==e?(this._low=this._high,this._high=0):(this._low=this._low>>e|this._high<<16-e&65535,this._high>>=e),this},o.prototype.shiftLeft=o.prototype.shiftl=function(e,t){return e>16?(this._high=this._low<>16-e,this._low=this._low<>>32-e,this._low=65535&t,this._high=t>>>16,this},o.prototype.rotateRight=o.prototype.rotr=function(e){var t=this._high<<16|this._low;return t=t>>>e|t<<32-e,this._low=65535&t,this._high=t>>>16,this},o.prototype.clone=function(){return new o(this._low,this._high)},void 0===(p=function(){return o}.apply(t,[]))||(e.exports=p)}()},function(e,t,r){var p;!function(r){var o={16:s(Math.pow(16,5)),10:s(Math.pow(10,5)),2:s(Math.pow(2,5))},i={16:s(16),10:s(10),2:s(2)};function s(e,t,r,p){return this instanceof s?(this.remainder=null,"string"==typeof e?l.call(this,e,t):void 0===t?a.call(this,e):void n.apply(this,arguments)):new s(e,t,r,p)}function n(e,t,r,p){return void 0===r?(this._a00=65535&e,this._a16=e>>>16,this._a32=65535&t,this._a48=t>>>16,this):(this._a00=0|e,this._a16=0|t,this._a32=0|r,this._a48=0|p,this)}function a(e){return this._a00=65535&e,this._a16=e>>>16,this._a32=0,this._a48=0,this}function l(e,t){t=t||10,this._a00=0,this._a16=0,this._a32=0,this._a48=0;for(var r=o[t]||new s(Math.pow(t,5)),p=0,i=e.length;p=0&&(r.div(t),p[o]=r.remainder.toNumber().toString(e),r.gt(t));o--);return p[o-1]=r.toNumber().toString(e),p.join("")},s.prototype.add=function(e){var t=this._a00+e._a00,r=t>>>16,p=(r+=this._a16+e._a16)>>>16,o=(p+=this._a32+e._a32)>>>16;return o+=this._a48+e._a48,this._a00=65535&t,this._a16=65535&r,this._a32=65535&p,this._a48=65535&o,this},s.prototype.subtract=function(e){return this.add(e.clone().negate())},s.prototype.multiply=function(e){var t=this._a00,r=this._a16,p=this._a32,o=this._a48,i=e._a00,s=e._a16,n=e._a32,a=t*i,l=a>>>16,c=(l+=t*s)>>>16;l&=65535,c+=(l+=r*i)>>>16;var u=(c+=t*n)>>>16;return c&=65535,u+=(c+=r*s)>>>16,c&=65535,u+=(c+=p*i)>>>16,u+=t*e._a48,u&=65535,u+=r*n,u&=65535,u+=p*s,u&=65535,u+=o*i,this._a00=65535&a,this._a16=65535&l,this._a32=65535&c,this._a48=65535&u,this},s.prototype.div=function(e){if(0==e._a16&&0==e._a32&&0==e._a48){if(0==e._a00)throw Error("division by zero");if(1==e._a00)return this.remainder=new s(0),this}if(e.gt(this))return this.remainder=this.clone(),this._a00=0,this._a16=0,this._a32=0,this._a48=0,this;if(this.eq(e))return this.remainder=new s(0),this._a00=1,this._a16=0,this._a32=0,this._a48=0,this;for(var t=e.clone(),r=-1;!this.lt(t);)t.shiftLeft(1,!0),r++;for(this.remainder=this.clone(),this._a00=0,this._a16=0,this._a32=0,this._a48=0;r>=0;r--)t.shiftRight(1),this.remainder.lt(t)||(this.remainder.subtract(t),r>=48?this._a48|=1<=32?this._a32|=1<=16?this._a16|=1<>>16),this._a16=65535&e,e=(65535&~this._a32)+(e>>>16),this._a32=65535&e,this._a48=~this._a48+(e>>>16)&65535,this},s.prototype.equals=s.prototype.eq=function(e){return this._a48==e._a48&&this._a00==e._a00&&this._a32==e._a32&&this._a16==e._a16},s.prototype.greaterThan=s.prototype.gt=function(e){return this._a48>e._a48||!(this._a48e._a32||!(this._a32e._a16||!(this._a16e._a00))},s.prototype.lessThan=s.prototype.lt=function(e){return this._a48e._a48)&&(this._a32e._a32)&&(this._a16e._a16)&&this._a00=48?(this._a00=this._a48>>e-48,this._a16=0,this._a32=0,this._a48=0):e>=32?(e-=32,this._a00=65535&(this._a32>>e|this._a48<<16-e),this._a16=this._a48>>e&65535,this._a32=0,this._a48=0):e>=16?(e-=16,this._a00=65535&(this._a16>>e|this._a32<<16-e),this._a16=65535&(this._a32>>e|this._a48<<16-e),this._a32=this._a48>>e&65535,this._a48=0):(this._a00=65535&(this._a00>>e|this._a16<<16-e),this._a16=65535&(this._a16>>e|this._a32<<16-e),this._a32=65535&(this._a32>>e|this._a48<<16-e),this._a48=this._a48>>e&65535),this},s.prototype.shiftLeft=s.prototype.shiftl=function(e,t){return(e%=64)>=48?(this._a48=this._a00<=32?(e-=32,this._a48=this._a16<>16-e,this._a32=this._a00<=16?(e-=16,this._a48=this._a32<>16-e,this._a32=65535&(this._a16<>16-e),this._a16=this._a00<>16-e,this._a32=65535&(this._a32<>16-e),this._a16=65535&(this._a16<>16-e),this._a00=this._a00<=32){var t=this._a00;if(this._a00=this._a32,this._a32=t,t=this._a48,this._a48=this._a16,this._a16=t,32==e)return this;e-=32}var r=this._a48<<16|this._a32,p=this._a16<<16|this._a00,o=r<>>32-e,i=p<>>32-e;return this._a00=65535&i,this._a16=i>>>16,this._a32=65535&o,this._a48=o>>>16,this},s.prototype.rotateRight=s.prototype.rotr=function(e){if(0==(e%=64))return this;if(e>=32){var t=this._a00;if(this._a00=this._a32,this._a32=t,t=this._a48,this._a48=this._a16,this._a16=t,32==e)return this;e-=32}var r=this._a48<<16|this._a32,p=this._a16<<16|this._a00,o=r>>>e|p<<32-e,i=p>>>e|r<<32-e;return this._a00=65535&i,this._a16=i>>>16,this._a32=65535&o,this._a48=o>>>16,this},s.prototype.clone=function(){return new s(this._a00,this._a16,this._a32,this._a48)},void 0===(p=function(){return s}.apply(t,[]))||(e.exports=p)}()},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,r(0).CarrierPhase,r(0).GnssSignal),s=r(0).GnssSignalDep,n=(r(0).GPSTime,r(0).GPSTimeDep,r(0).GPSTimeSec,r(0).SvId,function(e,t){return p.call(this,e),this.messageType="MSG_ACQ_RESULT",this.fields=t||this.parser.parse(e.payload),this});(n.prototype=Object.create(p.prototype)).messageType="MSG_ACQ_RESULT",n.prototype.msg_type=47,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").floatle("cn0").floatle("cp").floatle("cf").nest("sid",{type:i.prototype.parser}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["cn0","writeFloatLE",4]),n.prototype.fieldSpec.push(["cp","writeFloatLE",4]),n.prototype.fieldSpec.push(["cf","writeFloatLE",4]),n.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]);var a=function(e,t){return p.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="MSG_ACQ_RESULT_DEP_C",a.prototype.msg_type=31,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").floatle("cn0").floatle("cp").floatle("cf").nest("sid",{type:s.prototype.parser}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["cn0","writeFloatLE",4]),a.prototype.fieldSpec.push(["cp","writeFloatLE",4]),a.prototype.fieldSpec.push(["cf","writeFloatLE",4]),a.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);var l=function(e,t){return p.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="MSG_ACQ_RESULT_DEP_B",l.prototype.msg_type=20,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").floatle("snr").floatle("cp").floatle("cf").nest("sid",{type:s.prototype.parser}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["snr","writeFloatLE",4]),l.prototype.fieldSpec.push(["cp","writeFloatLE",4]),l.prototype.fieldSpec.push(["cf","writeFloatLE",4]),l.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);var c=function(e,t){return p.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="MSG_ACQ_RESULT_DEP_A",c.prototype.msg_type=21,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").floatle("snr").floatle("cp").floatle("cf").uint8("prn"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["snr","writeFloatLE",4]),c.prototype.fieldSpec.push(["cp","writeFloatLE",4]),c.prototype.fieldSpec.push(["cf","writeFloatLE",4]),c.prototype.fieldSpec.push(["prn","writeUInt8",1]);var u=function(e,t){return p.call(this,e),this.messageType="AcqSvProfile",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="AcqSvProfile",u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint8("job_type").uint8("status").uint16("cn0").uint8("int_time").nest("sid",{type:i.prototype.parser}).uint16("bin_width").uint32("timestamp").uint32("time_spent").int32("cf_min").int32("cf_max").int32("cf").uint32("cp"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["job_type","writeUInt8",1]),u.prototype.fieldSpec.push(["status","writeUInt8",1]),u.prototype.fieldSpec.push(["cn0","writeUInt16LE",2]),u.prototype.fieldSpec.push(["int_time","writeUInt8",1]),u.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),u.prototype.fieldSpec.push(["bin_width","writeUInt16LE",2]),u.prototype.fieldSpec.push(["timestamp","writeUInt32LE",4]),u.prototype.fieldSpec.push(["time_spent","writeUInt32LE",4]),u.prototype.fieldSpec.push(["cf_min","writeInt32LE",4]),u.prototype.fieldSpec.push(["cf_max","writeInt32LE",4]),u.prototype.fieldSpec.push(["cf","writeInt32LE",4]),u.prototype.fieldSpec.push(["cp","writeUInt32LE",4]);var y=function(e,t){return p.call(this,e),this.messageType="AcqSvProfileDep",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="AcqSvProfileDep",y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint8("job_type").uint8("status").uint16("cn0").uint8("int_time").nest("sid",{type:s.prototype.parser}).uint16("bin_width").uint32("timestamp").uint32("time_spent").int32("cf_min").int32("cf_max").int32("cf").uint32("cp"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["job_type","writeUInt8",1]),y.prototype.fieldSpec.push(["status","writeUInt8",1]),y.prototype.fieldSpec.push(["cn0","writeUInt16LE",2]),y.prototype.fieldSpec.push(["int_time","writeUInt8",1]),y.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),y.prototype.fieldSpec.push(["bin_width","writeUInt16LE",2]),y.prototype.fieldSpec.push(["timestamp","writeUInt32LE",4]),y.prototype.fieldSpec.push(["time_spent","writeUInt32LE",4]),y.prototype.fieldSpec.push(["cf_min","writeInt32LE",4]),y.prototype.fieldSpec.push(["cf_max","writeInt32LE",4]),y.prototype.fieldSpec.push(["cf","writeInt32LE",4]),y.prototype.fieldSpec.push(["cp","writeUInt32LE",4]);var h=function(e,t){return p.call(this,e),this.messageType="MSG_ACQ_SV_PROFILE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_ACQ_SV_PROFILE",h.prototype.msg_type=46,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").array("acq_sv_profile",{type:u.prototype.parser,readUntil:"eof"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["acq_sv_profile","array",u.prototype.fieldSpec,function(){return this.fields.array.length},null]);var f=function(e,t){return p.call(this,e),this.messageType="MSG_ACQ_SV_PROFILE_DEP",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="MSG_ACQ_SV_PROFILE_DEP",f.prototype.msg_type=30,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").array("acq_sv_profile",{type:y.prototype.parser,readUntil:"eof"}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["acq_sv_profile","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={47:n,MsgAcqResult:n,31:a,MsgAcqResultDepC:a,20:l,MsgAcqResultDepB:l,21:c,MsgAcqResultDepA:c,AcqSvProfile:u,AcqSvProfileDep:y,46:h,MsgAcqSvProfile:h,30:f,MsgAcqSvProfileDep:f}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_REQ",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_BOOTLOADER_HANDSHAKE_REQ",i.prototype.msg_type=179,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little"),i.prototype.fieldSpec=[];var s=function(e,t){return p.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_RESP",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_BOOTLOADER_HANDSHAKE_RESP",s.prototype.msg_type=180,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint32("flags").string("version",{greedy:!0}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["flags","writeUInt32LE",4]),s.prototype.fieldSpec.push(["version","string",null]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_BOOTLOADER_JUMP_TO_APP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_BOOTLOADER_JUMP_TO_APP",n.prototype.msg_type=177,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("jump"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["jump","writeUInt8",1]);var a=function(e,t){return p.call(this,e),this.messageType="MSG_NAP_DEVICE_DNA_REQ",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="MSG_NAP_DEVICE_DNA_REQ",a.prototype.msg_type=222,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little"),a.prototype.fieldSpec=[];var l=function(e,t){return p.call(this,e),this.messageType="MSG_NAP_DEVICE_DNA_RESP",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="MSG_NAP_DEVICE_DNA_RESP",l.prototype.msg_type=221,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").array("dna",{length:8,type:"uint8"}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["dna","array","writeUInt8",function(){return 1},8]);var c=function(e,t){return p.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="MSG_BOOTLOADER_HANDSHAKE_DEP_A",c.prototype.msg_type=176,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").array("handshake",{type:"uint8",readUntil:"eof"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["handshake","array","writeUInt8",function(){return 1},null]),e.exports={179:i,MsgBootloaderHandshakeReq:i,180:s,MsgBootloaderHandshakeResp:s,177:n,MsgBootloaderJumpToApp:n,222:a,MsgNapDeviceDnaReq:a,221:l,MsgNapDeviceDnaResp:l,176:c,MsgBootloaderHandshakeDepA:c}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_EXT_EVENT",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_EXT_EVENT",i.prototype.msg_type=257,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").int32("ns_residual").uint8("flags").uint8("pin"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]),i.prototype.fieldSpec.push(["pin","writeUInt8",1]),e.exports={257:i,MsgExtEvent:i}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_READ_REQ",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_READ_REQ",i.prototype.msg_type=168,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("offset").uint8("chunk_size").string("filename",{greedy:!0}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),i.prototype.fieldSpec.push(["offset","writeUInt32LE",4]),i.prototype.fieldSpec.push(["chunk_size","writeUInt8",1]),i.prototype.fieldSpec.push(["filename","string",null]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_READ_RESP",s.prototype.msg_type=163,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint32("sequence").array("contents",{type:"uint8",readUntil:"eof"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),s.prototype.fieldSpec.push(["contents","array","writeUInt8",function(){return 1},null]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_READ_DIR_REQ",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_READ_DIR_REQ",n.prototype.msg_type=169,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("offset").string("dirname",{greedy:!0}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),n.prototype.fieldSpec.push(["offset","writeUInt32LE",4]),n.prototype.fieldSpec.push(["dirname","string",null]);var a=function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_READ_DIR_RESP",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_READ_DIR_RESP",a.prototype.msg_type=170,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint32("sequence").array("contents",{type:"uint8",readUntil:"eof"}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),a.prototype.fieldSpec.push(["contents","array","writeUInt8",function(){return 1},null]);var l=function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_REMOVE",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_REMOVE",l.prototype.msg_type=172,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").string("filename",{greedy:!0}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["filename","string",null]);var c=function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_WRITE_REQ",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_WRITE_REQ",c.prototype.msg_type=173,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("offset").string("filename",{greedy:!0}).array("data",{type:"uint8",readUntil:"eof"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),c.prototype.fieldSpec.push(["offset","writeUInt32LE",4]),c.prototype.fieldSpec.push(["filename","string",null]),c.prototype.fieldSpec.push(["data","array","writeUInt8",function(){return 1},null]);var u=function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_WRITE_RESP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_WRITE_RESP",u.prototype.msg_type=171,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("sequence"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]);var y=function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_CONFIG_REQ",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_CONFIG_REQ",y.prototype.msg_type=4097,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint32("sequence"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]);var h=function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_CONFIG_RESP",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_CONFIG_RESP",h.prototype.msg_type=4098,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("window_size").uint32("batch_size").uint32("fileio_version"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),h.prototype.fieldSpec.push(["window_size","writeUInt32LE",4]),h.prototype.fieldSpec.push(["batch_size","writeUInt32LE",4]),h.prototype.fieldSpec.push(["fileio_version","writeUInt32LE",4]),e.exports={168:i,MsgFileioReadReq:i,163:s,MsgFileioReadResp:s,169:n,MsgFileioReadDirReq:n,170:a,MsgFileioReadDirResp:a,172:l,MsgFileioRemove:l,173:c,MsgFileioWriteReq:c,171:u,MsgFileioWriteResp:u,4097:y,MsgFileioConfigReq:y,4098:h,MsgFileioConfigResp:h}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_FLASH_PROGRAM",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_FLASH_PROGRAM",i.prototype.msg_type=230,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("target").array("addr_start",{length:3,type:"uint8"}).uint8("addr_len").array("data",{type:"uint8",length:"addr_len"}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["target","writeUInt8",1]),i.prototype.fieldSpec.push(["addr_start","array","writeUInt8",function(){return 1},3]),i.prototype.fieldSpec.push(["addr_len","writeUInt8",1]),i.prototype.fieldSpec.push(["data","array","writeUInt8",function(){return 1},"addr_len"]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_FLASH_DONE",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_FLASH_DONE",s.prototype.msg_type=224,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("response"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["response","writeUInt8",1]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_FLASH_READ_REQ",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_FLASH_READ_REQ",n.prototype.msg_type=231,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("target").array("addr_start",{length:3,type:"uint8"}).uint8("addr_len"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["target","writeUInt8",1]),n.prototype.fieldSpec.push(["addr_start","array","writeUInt8",function(){return 1},3]),n.prototype.fieldSpec.push(["addr_len","writeUInt8",1]);var a=function(e,t){return p.call(this,e),this.messageType="MSG_FLASH_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="MSG_FLASH_READ_RESP",a.prototype.msg_type=225,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("target").array("addr_start",{length:3,type:"uint8"}).uint8("addr_len"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["target","writeUInt8",1]),a.prototype.fieldSpec.push(["addr_start","array","writeUInt8",function(){return 1},3]),a.prototype.fieldSpec.push(["addr_len","writeUInt8",1]);var l=function(e,t){return p.call(this,e),this.messageType="MSG_FLASH_ERASE",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="MSG_FLASH_ERASE",l.prototype.msg_type=226,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("target").uint32("sector_num"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["target","writeUInt8",1]),l.prototype.fieldSpec.push(["sector_num","writeUInt32LE",4]);var c=function(e,t){return p.call(this,e),this.messageType="MSG_STM_FLASH_LOCK_SECTOR",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="MSG_STM_FLASH_LOCK_SECTOR",c.prototype.msg_type=227,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("sector"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["sector","writeUInt32LE",4]);var u=function(e,t){return p.call(this,e),this.messageType="MSG_STM_FLASH_UNLOCK_SECTOR",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="MSG_STM_FLASH_UNLOCK_SECTOR",u.prototype.msg_type=228,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("sector"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["sector","writeUInt32LE",4]);var y=function(e,t){return p.call(this,e),this.messageType="MSG_STM_UNIQUE_ID_REQ",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="MSG_STM_UNIQUE_ID_REQ",y.prototype.msg_type=232,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little"),y.prototype.fieldSpec=[];var h=function(e,t){return p.call(this,e),this.messageType="MSG_STM_UNIQUE_ID_RESP",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_STM_UNIQUE_ID_RESP",h.prototype.msg_type=229,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").array("stm_id",{length:12,type:"uint8"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["stm_id","array","writeUInt8",function(){return 1},12]);var f=function(e,t){return p.call(this,e),this.messageType="MSG_M25_FLASH_WRITE_STATUS",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="MSG_M25_FLASH_WRITE_STATUS",f.prototype.msg_type=243,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").array("status",{length:1,type:"uint8"}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["status","array","writeUInt8",function(){return 1},1]),e.exports={230:i,MsgFlashProgram:i,224:s,MsgFlashDone:s,231:n,MsgFlashReadReq:n,225:a,MsgFlashReadResp:a,226:l,MsgFlashErase:l,227:c,MsgStmFlashLockSector:c,228:u,MsgStmFlashUnlockSector:u,232:y,MsgStmUniqueIdReq:y,229:h,MsgStmUniqueIdResp:h,243:f,MsgM25FlashWriteStatus:f}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_IMU_RAW",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_IMU_RAW",i.prototype.msg_type=2304,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("tow").uint8("tow_f").int16("acc_x").int16("acc_y").int16("acc_z").int16("gyr_x").int16("gyr_y").int16("gyr_z"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["tow_f","writeUInt8",1]),i.prototype.fieldSpec.push(["acc_x","writeInt16LE",2]),i.prototype.fieldSpec.push(["acc_y","writeInt16LE",2]),i.prototype.fieldSpec.push(["acc_z","writeInt16LE",2]),i.prototype.fieldSpec.push(["gyr_x","writeInt16LE",2]),i.prototype.fieldSpec.push(["gyr_y","writeInt16LE",2]),i.prototype.fieldSpec.push(["gyr_z","writeInt16LE",2]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_IMU_AUX",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_IMU_AUX",s.prototype.msg_type=2305,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("imu_type").int16("temp").uint8("imu_conf"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["imu_type","writeUInt8",1]),s.prototype.fieldSpec.push(["temp","writeInt16LE",2]),s.prototype.fieldSpec.push(["imu_conf","writeUInt8",1]),e.exports={2304:i,MsgImuRaw:i,2305:s,MsgImuAux:s}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_CPU_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_CPU_STATE_DEP_A",i.prototype.msg_type=32512,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pcpu").string("tname",{length:15}).string("cmdline",{greedy:!0}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["index","writeUInt8",1]),i.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),i.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),i.prototype.fieldSpec.push(["tname","string",15]),i.prototype.fieldSpec.push(["cmdline","string",null]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_MEM_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_MEM_STATE_DEP_A",s.prototype.msg_type=32513,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pmem").string("tname",{length:15}).string("cmdline",{greedy:!0}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["index","writeUInt8",1]),s.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),s.prototype.fieldSpec.push(["pmem","writeUInt8",1]),s.prototype.fieldSpec.push(["tname","string",15]),s.prototype.fieldSpec.push(["cmdline","string",null]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_SYS_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_SYS_STATE_DEP_A",n.prototype.msg_type=32514,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint16("mem_total").uint8("pcpu").uint8("pmem").uint16("procs_starting").uint16("procs_stopping").uint16("pid_count"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["mem_total","writeUInt16LE",2]),n.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),n.prototype.fieldSpec.push(["pmem","writeUInt8",1]),n.prototype.fieldSpec.push(["procs_starting","writeUInt16LE",2]),n.prototype.fieldSpec.push(["procs_stopping","writeUInt16LE",2]),n.prototype.fieldSpec.push(["pid_count","writeUInt16LE",2]);var a=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_PROCESS_SOCKET_COUNTS",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_PROCESS_SOCKET_COUNTS",a.prototype.msg_type=32515,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint16("socket_count").uint16("socket_types").uint16("socket_states").string("cmdline",{greedy:!0}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["index","writeUInt8",1]),a.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),a.prototype.fieldSpec.push(["socket_count","writeUInt16LE",2]),a.prototype.fieldSpec.push(["socket_types","writeUInt16LE",2]),a.prototype.fieldSpec.push(["socket_states","writeUInt16LE",2]),a.prototype.fieldSpec.push(["cmdline","string",null]);var l=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_PROCESS_SOCKET_QUEUES",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_PROCESS_SOCKET_QUEUES",l.prototype.msg_type=32516,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint16("recv_queued").uint16("send_queued").uint16("socket_types").uint16("socket_states").string("address_of_largest",{length:64}).string("cmdline",{greedy:!0}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["index","writeUInt8",1]),l.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),l.prototype.fieldSpec.push(["recv_queued","writeUInt16LE",2]),l.prototype.fieldSpec.push(["send_queued","writeUInt16LE",2]),l.prototype.fieldSpec.push(["socket_types","writeUInt16LE",2]),l.prototype.fieldSpec.push(["socket_states","writeUInt16LE",2]),l.prototype.fieldSpec.push(["address_of_largest","string",64]),l.prototype.fieldSpec.push(["cmdline","string",null]);var c=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_SOCKET_USAGE",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_SOCKET_USAGE",c.prototype.msg_type=32517,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("avg_queue_depth").uint32("max_queue_depth").array("socket_state_counts",{length:16,type:"uint16le"}).array("socket_type_counts",{length:16,type:"uint16le"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["avg_queue_depth","writeUInt32LE",4]),c.prototype.fieldSpec.push(["max_queue_depth","writeUInt32LE",4]),c.prototype.fieldSpec.push(["socket_state_counts","array","writeUInt16LE",function(){return 2},16]),c.prototype.fieldSpec.push(["socket_type_counts","array","writeUInt16LE",function(){return 2},16]);var u=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_PROCESS_FD_COUNT",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_PROCESS_FD_COUNT",u.prototype.msg_type=32518,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint16("fd_count").string("cmdline",{greedy:!0}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["index","writeUInt8",1]),u.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),u.prototype.fieldSpec.push(["fd_count","writeUInt16LE",2]),u.prototype.fieldSpec.push(["cmdline","string",null]);var y=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_PROCESS_FD_SUMMARY",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_PROCESS_FD_SUMMARY",y.prototype.msg_type=32519,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint32("sys_fd_count").string("most_opened",{greedy:!0}),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["sys_fd_count","writeUInt32LE",4]),y.prototype.fieldSpec.push(["most_opened","string",null]);var h=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_CPU_STATE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_CPU_STATE",h.prototype.msg_type=32520,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pcpu").uint32("time").uint8("flags").string("tname",{length:15}).string("cmdline",{greedy:!0}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["index","writeUInt8",1]),h.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),h.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),h.prototype.fieldSpec.push(["time","writeUInt32LE",4]),h.prototype.fieldSpec.push(["flags","writeUInt8",1]),h.prototype.fieldSpec.push(["tname","string",15]),h.prototype.fieldSpec.push(["cmdline","string",null]);var f=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_MEM_STATE",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_MEM_STATE",f.prototype.msg_type=32521,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pmem").uint32("time").uint8("flags").string("tname",{length:15}).string("cmdline",{greedy:!0}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["index","writeUInt8",1]),f.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),f.prototype.fieldSpec.push(["pmem","writeUInt8",1]),f.prototype.fieldSpec.push(["time","writeUInt32LE",4]),f.prototype.fieldSpec.push(["flags","writeUInt8",1]),f.prototype.fieldSpec.push(["tname","string",15]),f.prototype.fieldSpec.push(["cmdline","string",null]);var d=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_SYS_STATE",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_SYS_STATE",d.prototype.msg_type=32522,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint16("mem_total").uint8("pcpu").uint8("pmem").uint16("procs_starting").uint16("procs_stopping").uint16("pid_count").uint32("time").uint8("flags"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["mem_total","writeUInt16LE",2]),d.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),d.prototype.fieldSpec.push(["pmem","writeUInt8",1]),d.prototype.fieldSpec.push(["procs_starting","writeUInt16LE",2]),d.prototype.fieldSpec.push(["procs_stopping","writeUInt16LE",2]),d.prototype.fieldSpec.push(["pid_count","writeUInt16LE",2]),d.prototype.fieldSpec.push(["time","writeUInt32LE",4]),d.prototype.fieldSpec.push(["flags","writeUInt8",1]),e.exports={32512:i,MsgLinuxCpuStateDepA:i,32513:s,MsgLinuxMemStateDepA:s,32514:n,MsgLinuxSysStateDepA:n,32515:a,MsgLinuxProcessSocketCounts:a,32516:l,MsgLinuxProcessSocketQueues:l,32517:c,MsgLinuxSocketUsage:c,32518:u,MsgLinuxProcessFdCount:u,32519:y,MsgLinuxProcessFdSummary:y,32520:h,MsgLinuxCpuState:h,32521:f,MsgLinuxMemState:f,32522:d,MsgLinuxSysState:d}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_LOG",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_LOG",i.prototype.msg_type=1025,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("level").string("text",{greedy:!0}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["level","writeUInt8",1]),i.prototype.fieldSpec.push(["text","string",null]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_FWD",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_FWD",s.prototype.msg_type=1026,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("source").uint8("protocol").array("fwd_payload",{type:"uint8",readUntil:"eof"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["source","writeUInt8",1]),s.prototype.fieldSpec.push(["protocol","writeUInt8",1]),s.prototype.fieldSpec.push(["fwd_payload","array","writeUInt8",function(){return 1},null]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_PRINT_DEP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_PRINT_DEP",n.prototype.msg_type=16,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").string("text",{greedy:!0}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["text","string",null]),e.exports={1025:i,MsgLog:i,1026:s,MsgFwd:s,16:n,MsgPrintDep:n}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_MAG_RAW",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_MAG_RAW",i.prototype.msg_type=2306,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("tow").uint8("tow_f").int16("mag_x").int16("mag_y").int16("mag_z"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["tow_f","writeUInt8",1]),i.prototype.fieldSpec.push(["mag_x","writeInt16LE",2]),i.prototype.fieldSpec.push(["mag_y","writeInt16LE",2]),i.prototype.fieldSpec.push(["mag_z","writeInt16LE",2]),e.exports={2306:i,MsgMagRaw:i}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_GPS_TIME",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_GPS_TIME",i.prototype.msg_type=258,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").int32("ns_residual").uint8("flags"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_GPS_TIME_GNSS",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_GPS_TIME_GNSS",s.prototype.msg_type=260,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").int32("ns_residual").uint8("flags"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),s.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),s.prototype.fieldSpec.push(["flags","writeUInt8",1]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_UTC_TIME",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_UTC_TIME",n.prototype.msg_type=259,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("flags").uint32("tow").uint16("year").uint8("month").uint8("day").uint8("hours").uint8("minutes").uint8("seconds").uint32("ns"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["flags","writeUInt8",1]),n.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),n.prototype.fieldSpec.push(["year","writeUInt16LE",2]),n.prototype.fieldSpec.push(["month","writeUInt8",1]),n.prototype.fieldSpec.push(["day","writeUInt8",1]),n.prototype.fieldSpec.push(["hours","writeUInt8",1]),n.prototype.fieldSpec.push(["minutes","writeUInt8",1]),n.prototype.fieldSpec.push(["seconds","writeUInt8",1]),n.prototype.fieldSpec.push(["ns","writeUInt32LE",4]);var a=function(e,t){return p.call(this,e),this.messageType="MSG_UTC_TIME_GNSS",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="MSG_UTC_TIME_GNSS",a.prototype.msg_type=261,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("flags").uint32("tow").uint16("year").uint8("month").uint8("day").uint8("hours").uint8("minutes").uint8("seconds").uint32("ns"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["flags","writeUInt8",1]),a.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),a.prototype.fieldSpec.push(["year","writeUInt16LE",2]),a.prototype.fieldSpec.push(["month","writeUInt8",1]),a.prototype.fieldSpec.push(["day","writeUInt8",1]),a.prototype.fieldSpec.push(["hours","writeUInt8",1]),a.prototype.fieldSpec.push(["minutes","writeUInt8",1]),a.prototype.fieldSpec.push(["seconds","writeUInt8",1]),a.prototype.fieldSpec.push(["ns","writeUInt32LE",4]);var l=function(e,t){return p.call(this,e),this.messageType="MSG_DOPS",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="MSG_DOPS",l.prototype.msg_type=520,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint32("tow").uint16("gdop").uint16("pdop").uint16("tdop").uint16("hdop").uint16("vdop").uint8("flags"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),l.prototype.fieldSpec.push(["gdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["tdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["vdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["flags","writeUInt8",1]);var c=function(e,t){return p.call(this,e),this.messageType="MSG_POS_ECEF",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="MSG_POS_ECEF",c.prototype.msg_type=521,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").uint16("accuracy").uint8("n_sats").uint8("flags"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),c.prototype.fieldSpec.push(["x","writeDoubleLE",8]),c.prototype.fieldSpec.push(["y","writeDoubleLE",8]),c.prototype.fieldSpec.push(["z","writeDoubleLE",8]),c.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),c.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),c.prototype.fieldSpec.push(["flags","writeUInt8",1]);var u=function(e,t){return p.call(this,e),this.messageType="MSG_POS_ECEF_COV",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="MSG_POS_ECEF_COV",u.prototype.msg_type=532,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),u.prototype.fieldSpec.push(["x","writeDoubleLE",8]),u.prototype.fieldSpec.push(["y","writeDoubleLE",8]),u.prototype.fieldSpec.push(["z","writeDoubleLE",8]),u.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),u.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),u.prototype.fieldSpec.push(["flags","writeUInt8",1]);var y=function(e,t){return p.call(this,e),this.messageType="MSG_POS_LLH",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="MSG_POS_LLH",y.prototype.msg_type=522,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),y.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),y.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),y.prototype.fieldSpec.push(["height","writeDoubleLE",8]),y.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),y.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),y.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),y.prototype.fieldSpec.push(["flags","writeUInt8",1]);var h=function(e,t){return p.call(this,e),this.messageType="MSG_POS_LLH_COV",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_POS_LLH_COV",h.prototype.msg_type=529,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").floatle("cov_n_n").floatle("cov_n_e").floatle("cov_n_d").floatle("cov_e_e").floatle("cov_e_d").floatle("cov_d_d").uint8("n_sats").uint8("flags"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),h.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),h.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),h.prototype.fieldSpec.push(["height","writeDoubleLE",8]),h.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),h.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),h.prototype.fieldSpec.push(["flags","writeUInt8",1]);var f=function(e,t){return p.call(this,e),this.messageType="EstimatedHorizontalErrorEllipse",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="EstimatedHorizontalErrorEllipse",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").floatle("semi_major").floatle("semi_minor").floatle("orientation"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["semi_major","writeFloatLE",4]),f.prototype.fieldSpec.push(["semi_minor","writeFloatLE",4]),f.prototype.fieldSpec.push(["orientation","writeFloatLE",4]);var d=function(e,t){return p.call(this,e),this.messageType="MSG_POS_LLH_ACC",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(p.prototype)).messageType="MSG_POS_LLH_ACC",d.prototype.msg_type=536,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").doublele("orthometric_height").floatle("h_accuracy").floatle("v_accuracy").floatle("ct_accuracy").floatle("at_accuracy").nest("h_ellipse",{type:f.prototype.parser}).uint8("confidence_and_geoid").uint8("n_sats").uint8("flags"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),d.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),d.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),d.prototype.fieldSpec.push(["height","writeDoubleLE",8]),d.prototype.fieldSpec.push(["orthometric_height","writeDoubleLE",8]),d.prototype.fieldSpec.push(["h_accuracy","writeFloatLE",4]),d.prototype.fieldSpec.push(["v_accuracy","writeFloatLE",4]),d.prototype.fieldSpec.push(["ct_accuracy","writeFloatLE",4]),d.prototype.fieldSpec.push(["at_accuracy","writeFloatLE",4]),d.prototype.fieldSpec.push(["h_ellipse",f.prototype.fieldSpec]),d.prototype.fieldSpec.push(["confidence_and_geoid","writeUInt8",1]),d.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),d.prototype.fieldSpec.push(["flags","writeUInt8",1]);var _=function(e,t){return p.call(this,e),this.messageType="MSG_BASELINE_ECEF",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(p.prototype)).messageType="MSG_BASELINE_ECEF",_.prototype.msg_type=523,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),_.prototype.fieldSpec.push(["x","writeInt32LE",4]),_.prototype.fieldSpec.push(["y","writeInt32LE",4]),_.prototype.fieldSpec.push(["z","writeInt32LE",4]),_.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),_.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),_.prototype.fieldSpec.push(["flags","writeUInt8",1]);var S=function(e,t){return p.call(this,e),this.messageType="MSG_BASELINE_NED",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(p.prototype)).messageType="MSG_BASELINE_NED",S.prototype.msg_type=524,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),S.prototype.fieldSpec.push(["n","writeInt32LE",4]),S.prototype.fieldSpec.push(["e","writeInt32LE",4]),S.prototype.fieldSpec.push(["d","writeInt32LE",4]),S.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),S.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),S.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),S.prototype.fieldSpec.push(["flags","writeUInt8",1]);var g=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_ECEF",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(p.prototype)).messageType="MSG_VEL_ECEF",g.prototype.msg_type=525,g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),g.prototype.fieldSpec.push(["x","writeInt32LE",4]),g.prototype.fieldSpec.push(["y","writeInt32LE",4]),g.prototype.fieldSpec.push(["z","writeInt32LE",4]),g.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),g.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),g.prototype.fieldSpec.push(["flags","writeUInt8",1]);var w=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_ECEF_COV",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(p.prototype)).messageType="MSG_VEL_ECEF_COV",w.prototype.msg_type=533,w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),w.prototype.fieldSpec.push(["x","writeInt32LE",4]),w.prototype.fieldSpec.push(["y","writeInt32LE",4]),w.prototype.fieldSpec.push(["z","writeInt32LE",4]),w.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),w.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),w.prototype.fieldSpec.push(["flags","writeUInt8",1]);var E=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_NED",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(p.prototype)).messageType="MSG_VEL_NED",E.prototype.msg_type=526,E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),E.prototype.fieldSpec.push(["n","writeInt32LE",4]),E.prototype.fieldSpec.push(["e","writeInt32LE",4]),E.prototype.fieldSpec.push(["d","writeInt32LE",4]),E.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),E.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),E.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),E.prototype.fieldSpec.push(["flags","writeUInt8",1]);var m=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_NED_COV",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(p.prototype)).messageType="MSG_VEL_NED_COV",m.prototype.msg_type=530,m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").floatle("cov_n_n").floatle("cov_n_e").floatle("cov_n_d").floatle("cov_e_e").floatle("cov_e_d").floatle("cov_d_d").uint8("n_sats").uint8("flags"),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),m.prototype.fieldSpec.push(["n","writeInt32LE",4]),m.prototype.fieldSpec.push(["e","writeInt32LE",4]),m.prototype.fieldSpec.push(["d","writeInt32LE",4]),m.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),m.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),m.prototype.fieldSpec.push(["flags","writeUInt8",1]);var b=function(e,t){return p.call(this,e),this.messageType="MSG_POS_ECEF_GNSS",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(p.prototype)).messageType="MSG_POS_ECEF_GNSS",b.prototype.msg_type=553,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").uint16("accuracy").uint8("n_sats").uint8("flags"),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),b.prototype.fieldSpec.push(["x","writeDoubleLE",8]),b.prototype.fieldSpec.push(["y","writeDoubleLE",8]),b.prototype.fieldSpec.push(["z","writeDoubleLE",8]),b.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),b.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),b.prototype.fieldSpec.push(["flags","writeUInt8",1]);var v=function(e,t){return p.call(this,e),this.messageType="MSG_POS_ECEF_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(p.prototype)).messageType="MSG_POS_ECEF_COV_GNSS",v.prototype.msg_type=564,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),v.prototype.fieldSpec.push(["x","writeDoubleLE",8]),v.prototype.fieldSpec.push(["y","writeDoubleLE",8]),v.prototype.fieldSpec.push(["z","writeDoubleLE",8]),v.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),v.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),v.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),v.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),v.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),v.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),v.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),v.prototype.fieldSpec.push(["flags","writeUInt8",1]);var L=function(e,t){return p.call(this,e),this.messageType="MSG_POS_LLH_GNSS",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(p.prototype)).messageType="MSG_POS_LLH_GNSS",L.prototype.msg_type=554,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),L.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),L.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),L.prototype.fieldSpec.push(["height","writeDoubleLE",8]),L.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),L.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),L.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),L.prototype.fieldSpec.push(["flags","writeUInt8",1]);var I=function(e,t){return p.call(this,e),this.messageType="MSG_POS_LLH_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(p.prototype)).messageType="MSG_POS_LLH_COV_GNSS",I.prototype.msg_type=561,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").floatle("cov_n_n").floatle("cov_n_e").floatle("cov_n_d").floatle("cov_e_e").floatle("cov_e_d").floatle("cov_d_d").uint8("n_sats").uint8("flags"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),I.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),I.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),I.prototype.fieldSpec.push(["height","writeDoubleLE",8]),I.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),I.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),I.prototype.fieldSpec.push(["flags","writeUInt8",1]);var T=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_ECEF_GNSS",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(p.prototype)).messageType="MSG_VEL_ECEF_GNSS",T.prototype.msg_type=557,T.prototype.constructor=T,T.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),T.prototype.fieldSpec.push(["x","writeInt32LE",4]),T.prototype.fieldSpec.push(["y","writeInt32LE",4]),T.prototype.fieldSpec.push(["z","writeInt32LE",4]),T.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),T.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),T.prototype.fieldSpec.push(["flags","writeUInt8",1]);var U=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_ECEF_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(p.prototype)).messageType="MSG_VEL_ECEF_COV_GNSS",U.prototype.msg_type=565,U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),U.prototype.fieldSpec.push(["x","writeInt32LE",4]),U.prototype.fieldSpec.push(["y","writeInt32LE",4]),U.prototype.fieldSpec.push(["z","writeInt32LE",4]),U.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),U.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),U.prototype.fieldSpec.push(["flags","writeUInt8",1]);var M=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_NED_GNSS",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(p.prototype)).messageType="MSG_VEL_NED_GNSS",M.prototype.msg_type=558,M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),M.prototype.fieldSpec.push(["n","writeInt32LE",4]),M.prototype.fieldSpec.push(["e","writeInt32LE",4]),M.prototype.fieldSpec.push(["d","writeInt32LE",4]),M.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),M.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),M.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),M.prototype.fieldSpec.push(["flags","writeUInt8",1]);var D=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_NED_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(p.prototype)).messageType="MSG_VEL_NED_COV_GNSS",D.prototype.msg_type=562,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").floatle("cov_n_n").floatle("cov_n_e").floatle("cov_n_d").floatle("cov_e_e").floatle("cov_e_d").floatle("cov_d_d").uint8("n_sats").uint8("flags"),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),D.prototype.fieldSpec.push(["n","writeInt32LE",4]),D.prototype.fieldSpec.push(["e","writeInt32LE",4]),D.prototype.fieldSpec.push(["d","writeInt32LE",4]),D.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),D.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),D.prototype.fieldSpec.push(["flags","writeUInt8",1]);var O=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_BODY",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(p.prototype)).messageType="MSG_VEL_BODY",O.prototype.msg_type=531,O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),O.prototype.fieldSpec.push(["x","writeInt32LE",4]),O.prototype.fieldSpec.push(["y","writeInt32LE",4]),O.prototype.fieldSpec.push(["z","writeInt32LE",4]),O.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),O.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),O.prototype.fieldSpec.push(["flags","writeUInt8",1]);var G=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_COG",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(p.prototype)).messageType="MSG_VEL_COG",G.prototype.msg_type=540,G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").uint32("tow").uint32("cog").uint32("sog").int32("v_up").uint32("cog_accuracy").uint32("sog_accuracy").uint32("v_up_accuracy").uint16("flags"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),G.prototype.fieldSpec.push(["cog","writeUInt32LE",4]),G.prototype.fieldSpec.push(["sog","writeUInt32LE",4]),G.prototype.fieldSpec.push(["v_up","writeInt32LE",4]),G.prototype.fieldSpec.push(["cog_accuracy","writeUInt32LE",4]),G.prototype.fieldSpec.push(["sog_accuracy","writeUInt32LE",4]),G.prototype.fieldSpec.push(["v_up_accuracy","writeUInt32LE",4]),G.prototype.fieldSpec.push(["flags","writeUInt16LE",2]);var A=function(e,t){return p.call(this,e),this.messageType="MSG_AGE_CORRECTIONS",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(p.prototype)).messageType="MSG_AGE_CORRECTIONS",A.prototype.msg_type=528,A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").uint32("tow").uint16("age"),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),A.prototype.fieldSpec.push(["age","writeUInt16LE",2]);var C=function(e,t){return p.call(this,e),this.messageType="MSG_GPS_TIME_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(p.prototype)).messageType="MSG_GPS_TIME_DEP_A",C.prototype.msg_type=256,C.prototype.constructor=C,C.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").int32("ns_residual").uint8("flags"),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),C.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),C.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),C.prototype.fieldSpec.push(["flags","writeUInt8",1]);var R=function(e,t){return p.call(this,e),this.messageType="MSG_DOPS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(p.prototype)).messageType="MSG_DOPS_DEP_A",R.prototype.msg_type=518,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").uint32("tow").uint16("gdop").uint16("pdop").uint16("tdop").uint16("hdop").uint16("vdop"),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),R.prototype.fieldSpec.push(["gdop","writeUInt16LE",2]),R.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),R.prototype.fieldSpec.push(["tdop","writeUInt16LE",2]),R.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),R.prototype.fieldSpec.push(["vdop","writeUInt16LE",2]);var P=function(e,t){return p.call(this,e),this.messageType="MSG_POS_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(p.prototype)).messageType="MSG_POS_ECEF_DEP_A",P.prototype.msg_type=512,P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").uint16("accuracy").uint8("n_sats").uint8("flags"),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),P.prototype.fieldSpec.push(["x","writeDoubleLE",8]),P.prototype.fieldSpec.push(["y","writeDoubleLE",8]),P.prototype.fieldSpec.push(["z","writeDoubleLE",8]),P.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),P.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),P.prototype.fieldSpec.push(["flags","writeUInt8",1]);var N=function(e,t){return p.call(this,e),this.messageType="MSG_POS_LLH_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(p.prototype)).messageType="MSG_POS_LLH_DEP_A",N.prototype.msg_type=513,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),N.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),N.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),N.prototype.fieldSpec.push(["height","writeDoubleLE",8]),N.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),N.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),N.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),N.prototype.fieldSpec.push(["flags","writeUInt8",1]);var j=function(e,t){return p.call(this,e),this.messageType="MSG_BASELINE_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(p.prototype)).messageType="MSG_BASELINE_ECEF_DEP_A",j.prototype.msg_type=514,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),j.prototype.fieldSpec.push(["x","writeInt32LE",4]),j.prototype.fieldSpec.push(["y","writeInt32LE",4]),j.prototype.fieldSpec.push(["z","writeInt32LE",4]),j.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),j.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),j.prototype.fieldSpec.push(["flags","writeUInt8",1]);var x=function(e,t){return p.call(this,e),this.messageType="MSG_BASELINE_NED_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(p.prototype)).messageType="MSG_BASELINE_NED_DEP_A",x.prototype.msg_type=515,x.prototype.constructor=x,x.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),x.prototype.fieldSpec=[],x.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),x.prototype.fieldSpec.push(["n","writeInt32LE",4]),x.prototype.fieldSpec.push(["e","writeInt32LE",4]),x.prototype.fieldSpec.push(["d","writeInt32LE",4]),x.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),x.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),x.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),x.prototype.fieldSpec.push(["flags","writeUInt8",1]);var k=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(p.prototype)).messageType="MSG_VEL_ECEF_DEP_A",k.prototype.msg_type=516,k.prototype.constructor=k,k.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),k.prototype.fieldSpec=[],k.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),k.prototype.fieldSpec.push(["x","writeInt32LE",4]),k.prototype.fieldSpec.push(["y","writeInt32LE",4]),k.prototype.fieldSpec.push(["z","writeInt32LE",4]),k.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),k.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),k.prototype.fieldSpec.push(["flags","writeUInt8",1]);var F=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_NED_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(p.prototype)).messageType="MSG_VEL_NED_DEP_A",F.prototype.msg_type=517,F.prototype.constructor=F,F.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),F.prototype.fieldSpec=[],F.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),F.prototype.fieldSpec.push(["n","writeInt32LE",4]),F.prototype.fieldSpec.push(["e","writeInt32LE",4]),F.prototype.fieldSpec.push(["d","writeInt32LE",4]),F.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),F.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),F.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),F.prototype.fieldSpec.push(["flags","writeUInt8",1]);var B=function(e,t){return p.call(this,e),this.messageType="MSG_BASELINE_HEADING_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(B.prototype=Object.create(p.prototype)).messageType="MSG_BASELINE_HEADING_DEP_A",B.prototype.msg_type=519,B.prototype.constructor=B,B.prototype.parser=(new o).endianess("little").uint32("tow").uint32("heading").uint8("n_sats").uint8("flags"),B.prototype.fieldSpec=[],B.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),B.prototype.fieldSpec.push(["heading","writeUInt32LE",4]),B.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),B.prototype.fieldSpec.push(["flags","writeUInt8",1]);var q=function(e,t){return p.call(this,e),this.messageType="MSG_PROTECTION_LEVEL_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(p.prototype)).messageType="MSG_PROTECTION_LEVEL_DEP_A",q.prototype.msg_type=534,q.prototype.constructor=q,q.prototype.parser=(new o).endianess("little").uint32("tow").uint16("vpl").uint16("hpl").doublele("lat").doublele("lon").doublele("height").uint8("flags"),q.prototype.fieldSpec=[],q.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),q.prototype.fieldSpec.push(["vpl","writeUInt16LE",2]),q.prototype.fieldSpec.push(["hpl","writeUInt16LE",2]),q.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),q.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),q.prototype.fieldSpec.push(["height","writeDoubleLE",8]),q.prototype.fieldSpec.push(["flags","writeUInt8",1]);var z=function(e,t){return p.call(this,e),this.messageType="MSG_PROTECTION_LEVEL",this.fields=t||this.parser.parse(e.payload),this};(z.prototype=Object.create(p.prototype)).messageType="MSG_PROTECTION_LEVEL",z.prototype.msg_type=535,z.prototype.constructor=z,z.prototype.parser=(new o).endianess("little").uint32("tow").int16("wn").uint16("hpl").uint16("vpl").uint16("atpl").uint16("ctpl").uint16("hvpl").uint16("vvpl").uint16("hopl").uint16("popl").uint16("ropl").doublele("lat").doublele("lon").doublele("height").int32("v_x").int32("v_y").int32("v_z").int32("roll").int32("pitch").int32("heading").uint32("flags"),z.prototype.fieldSpec=[],z.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),z.prototype.fieldSpec.push(["wn","writeInt16LE",2]),z.prototype.fieldSpec.push(["hpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["vpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["atpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["ctpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["hvpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["vvpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["hopl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["popl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["ropl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),z.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),z.prototype.fieldSpec.push(["height","writeDoubleLE",8]),z.prototype.fieldSpec.push(["v_x","writeInt32LE",4]),z.prototype.fieldSpec.push(["v_y","writeInt32LE",4]),z.prototype.fieldSpec.push(["v_z","writeInt32LE",4]),z.prototype.fieldSpec.push(["roll","writeInt32LE",4]),z.prototype.fieldSpec.push(["pitch","writeInt32LE",4]),z.prototype.fieldSpec.push(["heading","writeInt32LE",4]),z.prototype.fieldSpec.push(["flags","writeUInt32LE",4]),e.exports={258:i,MsgGpsTime:i,260:s,MsgGpsTimeGnss:s,259:n,MsgUtcTime:n,261:a,MsgUtcTimeGnss:a,520:l,MsgDops:l,521:c,MsgPosEcef:c,532:u,MsgPosEcefCov:u,522:y,MsgPosLlh:y,529:h,MsgPosLlhCov:h,EstimatedHorizontalErrorEllipse:f,536:d,MsgPosLlhAcc:d,523:_,MsgBaselineEcef:_,524:S,MsgBaselineNed:S,525:g,MsgVelEcef:g,533:w,MsgVelEcefCov:w,526:E,MsgVelNed:E,530:m,MsgVelNedCov:m,553:b,MsgPosEcefGnss:b,564:v,MsgPosEcefCovGnss:v,554:L,MsgPosLlhGnss:L,561:I,MsgPosLlhCovGnss:I,557:T,MsgVelEcefGnss:T,565:U,MsgVelEcefCovGnss:U,558:M,MsgVelNedGnss:M,562:D,MsgVelNedCovGnss:D,531:O,MsgVelBody:O,540:G,MsgVelCog:G,528:A,MsgAgeCorrections:A,256:C,MsgGpsTimeDepA:C,518:R,MsgDopsDepA:R,512:P,MsgPosEcefDepA:P,513:N,MsgPosLlhDepA:N,514:j,MsgBaselineEcefDepA:j,515:x,MsgBaselineNedDepA:x,516:k,MsgVelEcefDepA:k,517:F,MsgVelNedDepA:F,519:B,MsgBaselineHeadingDepA:B,534:q,MsgProtectionLevelDepA:q,535:z,MsgProtectionLevel:z}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,r(0).CarrierPhase,r(0).GnssSignal),s=(r(0).GnssSignalDep,r(0).GPSTime,r(0).GPSTimeDep,r(0).GPSTimeSec,r(0).SvId,function(e,t){return p.call(this,e),this.messageType="MSG_NDB_EVENT",this.fields=t||this.parser.parse(e.payload),this});(s.prototype=Object.create(p.prototype)).messageType="MSG_NDB_EVENT",s.prototype.msg_type=1024,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint64("recv_time").uint8("event").uint8("object_type").uint8("result").uint8("data_source").nest("object_sid",{type:i.prototype.parser}).nest("src_sid",{type:i.prototype.parser}).uint16("original_sender"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["recv_time","writeUInt64LE",8]),s.prototype.fieldSpec.push(["event","writeUInt8",1]),s.prototype.fieldSpec.push(["object_type","writeUInt8",1]),s.prototype.fieldSpec.push(["result","writeUInt8",1]),s.prototype.fieldSpec.push(["data_source","writeUInt8",1]),s.prototype.fieldSpec.push(["object_sid",i.prototype.fieldSpec]),s.prototype.fieldSpec.push(["src_sid",i.prototype.fieldSpec]),s.prototype.fieldSpec.push(["original_sender","writeUInt16LE",2]),e.exports={1024:s,MsgNdbEvent:s}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,r(0).CarrierPhase),s=r(0).GnssSignal,n=r(0).GnssSignalDep,a=r(0).GPSTime,l=r(0).GPSTimeDep,c=r(0).GPSTimeSec,u=(r(0).SvId,function(e,t){return p.call(this,e),this.messageType="ObservationHeader",this.fields=t||this.parser.parse(e.payload),this});(u.prototype=Object.create(p.prototype)).messageType="ObservationHeader",u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").nest("t",{type:a.prototype.parser}).uint8("n_obs"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["t",a.prototype.fieldSpec]),u.prototype.fieldSpec.push(["n_obs","writeUInt8",1]);var y=function(e,t){return p.call(this,e),this.messageType="Doppler",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="Doppler",y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").int16("i").uint8("f"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["i","writeInt16LE",2]),y.prototype.fieldSpec.push(["f","writeUInt8",1]);var h=function(e,t){return p.call(this,e),this.messageType="PackedObsContent",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="PackedObsContent",h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:i.prototype.parser}).nest("D",{type:y.prototype.parser}).uint8("cn0").uint8("lock").uint8("flags").nest("sid",{type:s.prototype.parser}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["P","writeUInt32LE",4]),h.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),h.prototype.fieldSpec.push(["D",y.prototype.fieldSpec]),h.prototype.fieldSpec.push(["cn0","writeUInt8",1]),h.prototype.fieldSpec.push(["lock","writeUInt8",1]),h.prototype.fieldSpec.push(["flags","writeUInt8",1]),h.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);var f=function(e,t){return p.call(this,e),this.messageType="PackedOsrContent",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="PackedOsrContent",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:i.prototype.parser}).uint8("lock").uint8("flags").nest("sid",{type:s.prototype.parser}).uint16("iono_std").uint16("tropo_std").uint16("range_std"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["P","writeUInt32LE",4]),f.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),f.prototype.fieldSpec.push(["lock","writeUInt8",1]),f.prototype.fieldSpec.push(["flags","writeUInt8",1]),f.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),f.prototype.fieldSpec.push(["iono_std","writeUInt16LE",2]),f.prototype.fieldSpec.push(["tropo_std","writeUInt16LE",2]),f.prototype.fieldSpec.push(["range_std","writeUInt16LE",2]);var d=function(e,t){return p.call(this,e),this.messageType="MSG_OBS",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(p.prototype)).messageType="MSG_OBS",d.prototype.msg_type=74,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").nest("header",{type:u.prototype.parser}).array("obs",{type:h.prototype.parser,readUntil:"eof"}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["header",u.prototype.fieldSpec]),d.prototype.fieldSpec.push(["obs","array",h.prototype.fieldSpec,function(){return this.fields.array.length},null]);var _=function(e,t){return p.call(this,e),this.messageType="MSG_BASE_POS_LLH",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(p.prototype)).messageType="MSG_BASE_POS_LLH",_.prototype.msg_type=68,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").doublele("lat").doublele("lon").doublele("height"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),_.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),_.prototype.fieldSpec.push(["height","writeDoubleLE",8]);var S=function(e,t){return p.call(this,e),this.messageType="MSG_BASE_POS_ECEF",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(p.prototype)).messageType="MSG_BASE_POS_ECEF",S.prototype.msg_type=72,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").doublele("x").doublele("y").doublele("z"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["x","writeDoubleLE",8]),S.prototype.fieldSpec.push(["y","writeDoubleLE",8]),S.prototype.fieldSpec.push(["z","writeDoubleLE",8]);var g=function(e,t){return p.call(this,e),this.messageType="EphemerisCommonContent",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(p.prototype)).messageType="EphemerisCommonContent",g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).nest("toe",{type:c.prototype.parser}).floatle("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),g.prototype.fieldSpec.push(["toe",c.prototype.fieldSpec]),g.prototype.fieldSpec.push(["ura","writeFloatLE",4]),g.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),g.prototype.fieldSpec.push(["valid","writeUInt8",1]),g.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);var w=function(e,t){return p.call(this,e),this.messageType="EphemerisCommonContentDepB",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(p.prototype)).messageType="EphemerisCommonContentDepB",w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).nest("toe",{type:c.prototype.parser}).doublele("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),w.prototype.fieldSpec.push(["toe",c.prototype.fieldSpec]),w.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),w.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),w.prototype.fieldSpec.push(["valid","writeUInt8",1]),w.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);var E=function(e,t){return p.call(this,e),this.messageType="EphemerisCommonContentDepA",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(p.prototype)).messageType="EphemerisCommonContentDepA",E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").nest("sid",{type:n.prototype.parser}).nest("toe",{type:l.prototype.parser}).doublele("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),E.prototype.fieldSpec.push(["toe",l.prototype.fieldSpec]),E.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),E.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),E.prototype.fieldSpec.push(["valid","writeUInt8",1]),E.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);var m=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GPS_DEP_E",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GPS_DEP_E",m.prototype.msg_type=129,m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").nest("common",{type:E.prototype.parser}).doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").nest("toc",{type:l.prototype.parser}).uint8("iode").uint16("iodc"),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["common",E.prototype.fieldSpec]),m.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),m.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),m.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),m.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),m.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),m.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),m.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),m.prototype.fieldSpec.push(["w","writeDoubleLE",8]),m.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),m.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),m.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),m.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),m.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),m.prototype.fieldSpec.push(["toc",l.prototype.fieldSpec]),m.prototype.fieldSpec.push(["iode","writeUInt8",1]),m.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);var b=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GPS_DEP_F",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GPS_DEP_F",b.prototype.msg_type=134,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").nest("toc",{type:c.prototype.parser}).uint8("iode").uint16("iodc"),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),b.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),b.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),b.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),b.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),b.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),b.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),b.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),b.prototype.fieldSpec.push(["w","writeDoubleLE",8]),b.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),b.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),b.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),b.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),b.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),b.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),b.prototype.fieldSpec.push(["iode","writeUInt8",1]),b.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);var v=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GPS",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GPS",v.prototype.msg_type=138,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("tgd").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").floatle("af0").floatle("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint8("iode").uint16("iodc"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),v.prototype.fieldSpec.push(["tgd","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),v.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),v.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),v.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),v.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),v.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),v.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),v.prototype.fieldSpec.push(["w","writeDoubleLE",8]),v.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),v.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),v.prototype.fieldSpec.push(["af0","writeFloatLE",4]),v.prototype.fieldSpec.push(["af1","writeFloatLE",4]),v.prototype.fieldSpec.push(["af2","writeFloatLE",4]),v.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),v.prototype.fieldSpec.push(["iode","writeUInt8",1]),v.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);var L=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_QZSS",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_QZSS",L.prototype.msg_type=142,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("tgd").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").floatle("af0").floatle("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint8("iode").uint16("iodc"),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),L.prototype.fieldSpec.push(["tgd","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),L.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),L.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),L.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),L.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),L.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),L.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),L.prototype.fieldSpec.push(["w","writeDoubleLE",8]),L.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),L.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),L.prototype.fieldSpec.push(["af0","writeFloatLE",4]),L.prototype.fieldSpec.push(["af1","writeFloatLE",4]),L.prototype.fieldSpec.push(["af2","writeFloatLE",4]),L.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),L.prototype.fieldSpec.push(["iode","writeUInt8",1]),L.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);var I=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_BDS",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_BDS",I.prototype.msg_type=137,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("tgd1").floatle("tgd2").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").floatle("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint8("iode").uint16("iodc"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),I.prototype.fieldSpec.push(["tgd1","writeFloatLE",4]),I.prototype.fieldSpec.push(["tgd2","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),I.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),I.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),I.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),I.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),I.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),I.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),I.prototype.fieldSpec.push(["w","writeDoubleLE",8]),I.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),I.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),I.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),I.prototype.fieldSpec.push(["af1","writeFloatLE",4]),I.prototype.fieldSpec.push(["af2","writeFloatLE",4]),I.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),I.prototype.fieldSpec.push(["iode","writeUInt8",1]),I.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);var T=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GAL_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GAL_DEP_A",T.prototype.msg_type=149,T.prototype.constructor=T,T.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("bgd_e1e5a").floatle("bgd_e1e5b").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint16("iode").uint16("iodc"),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),T.prototype.fieldSpec.push(["bgd_e1e5a","writeFloatLE",4]),T.prototype.fieldSpec.push(["bgd_e1e5b","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),T.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),T.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),T.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),T.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),T.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),T.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),T.prototype.fieldSpec.push(["w","writeDoubleLE",8]),T.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),T.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),T.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),T.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),T.prototype.fieldSpec.push(["af2","writeFloatLE",4]),T.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),T.prototype.fieldSpec.push(["iode","writeUInt16LE",2]),T.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);var U=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GAL",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GAL",U.prototype.msg_type=141,U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("bgd_e1e5a").floatle("bgd_e1e5b").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint16("iode").uint16("iodc").uint8("source"),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),U.prototype.fieldSpec.push(["bgd_e1e5a","writeFloatLE",4]),U.prototype.fieldSpec.push(["bgd_e1e5b","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),U.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),U.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),U.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),U.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),U.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),U.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),U.prototype.fieldSpec.push(["w","writeDoubleLE",8]),U.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),U.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),U.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),U.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),U.prototype.fieldSpec.push(["af2","writeFloatLE",4]),U.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),U.prototype.fieldSpec.push(["iode","writeUInt16LE",2]),U.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]),U.prototype.fieldSpec.push(["source","writeUInt8",1]);var M=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_SBAS_DEP_A",M.prototype.msg_type=130,M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").nest("common",{type:E.prototype.parser}).array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}).doublele("a_gf0").doublele("a_gf1"),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["common",E.prototype.fieldSpec]),M.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),M.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),M.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),M.prototype.fieldSpec.push(["a_gf0","writeDoubleLE",8]),M.prototype.fieldSpec.push(["a_gf1","writeDoubleLE",8]);var D=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_A",D.prototype.msg_type=131,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").nest("common",{type:E.prototype.parser}).doublele("gamma").doublele("tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["common",E.prototype.fieldSpec]),D.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),D.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),D.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),D.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),D.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]);var O=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_SBAS_DEP_B",O.prototype.msg_type=132,O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}).doublele("a_gf0").doublele("a_gf1"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),O.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),O.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),O.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),O.prototype.fieldSpec.push(["a_gf0","writeDoubleLE",8]),O.prototype.fieldSpec.push(["a_gf1","writeDoubleLE",8]);var G=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_SBAS",G.prototype.msg_type=140,G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"floatle"}).array("acc",{length:3,type:"floatle"}).floatle("a_gf0").floatle("a_gf1"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),G.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),G.prototype.fieldSpec.push(["vel","array","writeFloatLE",function(){return 4},3]),G.prototype.fieldSpec.push(["acc","array","writeFloatLE",function(){return 4},3]),G.prototype.fieldSpec.push(["a_gf0","writeFloatLE",4]),G.prototype.fieldSpec.push(["a_gf1","writeFloatLE",4]);var A=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_B",A.prototype.msg_type=133,A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).doublele("gamma").doublele("tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),A.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),A.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),A.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),A.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),A.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]);var C=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_C",C.prototype.msg_type=135,C.prototype.constructor=C,C.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).doublele("gamma").doublele("tau").doublele("d_tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}).uint8("fcn"),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),C.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),C.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),C.prototype.fieldSpec.push(["d_tau","writeDoubleLE",8]),C.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),C.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),C.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),C.prototype.fieldSpec.push(["fcn","writeUInt8",1]);var R=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_D",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_D",R.prototype.msg_type=136,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).doublele("gamma").doublele("tau").doublele("d_tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}).uint8("fcn").uint8("iod"),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),R.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),R.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),R.prototype.fieldSpec.push(["d_tau","writeDoubleLE",8]),R.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),R.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),R.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),R.prototype.fieldSpec.push(["fcn","writeUInt8",1]),R.prototype.fieldSpec.push(["iod","writeUInt8",1]);var P=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GLO",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GLO",P.prototype.msg_type=139,P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("gamma").floatle("tau").floatle("d_tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"floatle"}).uint8("fcn").uint8("iod"),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),P.prototype.fieldSpec.push(["gamma","writeFloatLE",4]),P.prototype.fieldSpec.push(["tau","writeFloatLE",4]),P.prototype.fieldSpec.push(["d_tau","writeFloatLE",4]),P.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),P.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),P.prototype.fieldSpec.push(["acc","array","writeFloatLE",function(){return 4},3]),P.prototype.fieldSpec.push(["fcn","writeUInt8",1]),P.prototype.fieldSpec.push(["iod","writeUInt8",1]);var N=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_D",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_DEP_D",N.prototype.msg_type=128,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").doublele("toe_tow").uint16("toe_wn").doublele("toc_tow").uint16("toc_wn").uint8("valid").uint8("healthy").nest("sid",{type:n.prototype.parser}).uint8("iode").uint16("iodc").uint32("reserved"),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),N.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),N.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),N.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),N.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),N.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),N.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),N.prototype.fieldSpec.push(["w","writeDoubleLE",8]),N.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),N.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),N.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),N.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),N.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),N.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),N.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),N.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),N.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),N.prototype.fieldSpec.push(["valid","writeUInt8",1]),N.prototype.fieldSpec.push(["healthy","writeUInt8",1]),N.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),N.prototype.fieldSpec.push(["iode","writeUInt8",1]),N.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]),N.prototype.fieldSpec.push(["reserved","writeUInt32LE",4]);var j=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_DEP_A",j.prototype.msg_type=26,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").doublele("toe_tow").uint16("toe_wn").doublele("toc_tow").uint16("toc_wn").uint8("valid").uint8("healthy").uint8("prn"),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),j.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),j.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),j.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),j.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),j.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),j.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),j.prototype.fieldSpec.push(["w","writeDoubleLE",8]),j.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),j.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),j.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),j.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),j.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),j.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),j.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),j.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),j.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),j.prototype.fieldSpec.push(["valid","writeUInt8",1]),j.prototype.fieldSpec.push(["healthy","writeUInt8",1]),j.prototype.fieldSpec.push(["prn","writeUInt8",1]);var x=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_DEP_B",x.prototype.msg_type=70,x.prototype.constructor=x,x.prototype.parser=(new o).endianess("little").doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").doublele("toe_tow").uint16("toe_wn").doublele("toc_tow").uint16("toc_wn").uint8("valid").uint8("healthy").uint8("prn").uint8("iode"),x.prototype.fieldSpec=[],x.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),x.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),x.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),x.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),x.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),x.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),x.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),x.prototype.fieldSpec.push(["w","writeDoubleLE",8]),x.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),x.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),x.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),x.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),x.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),x.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),x.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),x.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),x.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),x.prototype.fieldSpec.push(["valid","writeUInt8",1]),x.prototype.fieldSpec.push(["healthy","writeUInt8",1]),x.prototype.fieldSpec.push(["prn","writeUInt8",1]),x.prototype.fieldSpec.push(["iode","writeUInt8",1]);var k=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_DEP_C",k.prototype.msg_type=71,k.prototype.constructor=k,k.prototype.parser=(new o).endianess("little").doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").doublele("toe_tow").uint16("toe_wn").doublele("toc_tow").uint16("toc_wn").uint8("valid").uint8("healthy").nest("sid",{type:n.prototype.parser}).uint8("iode").uint16("iodc").uint32("reserved"),k.prototype.fieldSpec=[],k.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),k.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),k.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),k.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),k.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),k.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),k.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),k.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),k.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),k.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),k.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),k.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),k.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),k.prototype.fieldSpec.push(["w","writeDoubleLE",8]),k.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),k.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),k.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),k.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),k.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),k.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),k.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),k.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),k.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),k.prototype.fieldSpec.push(["valid","writeUInt8",1]),k.prototype.fieldSpec.push(["healthy","writeUInt8",1]),k.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),k.prototype.fieldSpec.push(["iode","writeUInt8",1]),k.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]),k.prototype.fieldSpec.push(["reserved","writeUInt32LE",4]);var F=function(e,t){return p.call(this,e),this.messageType="ObservationHeaderDep",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(p.prototype)).messageType="ObservationHeaderDep",F.prototype.constructor=F,F.prototype.parser=(new o).endianess("little").nest("t",{type:l.prototype.parser}).uint8("n_obs"),F.prototype.fieldSpec=[],F.prototype.fieldSpec.push(["t",l.prototype.fieldSpec]),F.prototype.fieldSpec.push(["n_obs","writeUInt8",1]);var B=function(e,t){return p.call(this,e),this.messageType="CarrierPhaseDepA",this.fields=t||this.parser.parse(e.payload),this};(B.prototype=Object.create(p.prototype)).messageType="CarrierPhaseDepA",B.prototype.constructor=B,B.prototype.parser=(new o).endianess("little").int32("i").uint8("f"),B.prototype.fieldSpec=[],B.prototype.fieldSpec.push(["i","writeInt32LE",4]),B.prototype.fieldSpec.push(["f","writeUInt8",1]);var q=function(e,t){return p.call(this,e),this.messageType="PackedObsContentDepA",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(p.prototype)).messageType="PackedObsContentDepA",q.prototype.constructor=q,q.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:B.prototype.parser}).uint8("cn0").uint16("lock").uint8("prn"),q.prototype.fieldSpec=[],q.prototype.fieldSpec.push(["P","writeUInt32LE",4]),q.prototype.fieldSpec.push(["L",B.prototype.fieldSpec]),q.prototype.fieldSpec.push(["cn0","writeUInt8",1]),q.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),q.prototype.fieldSpec.push(["prn","writeUInt8",1]);var z=function(e,t){return p.call(this,e),this.messageType="PackedObsContentDepB",this.fields=t||this.parser.parse(e.payload),this};(z.prototype=Object.create(p.prototype)).messageType="PackedObsContentDepB",z.prototype.constructor=z,z.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:B.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:n.prototype.parser}),z.prototype.fieldSpec=[],z.prototype.fieldSpec.push(["P","writeUInt32LE",4]),z.prototype.fieldSpec.push(["L",B.prototype.fieldSpec]),z.prototype.fieldSpec.push(["cn0","writeUInt8",1]),z.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),z.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]);var V=function(e,t){return p.call(this,e),this.messageType="PackedObsContentDepC",this.fields=t||this.parser.parse(e.payload),this};(V.prototype=Object.create(p.prototype)).messageType="PackedObsContentDepC",V.prototype.constructor=V,V.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:i.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:n.prototype.parser}),V.prototype.fieldSpec=[],V.prototype.fieldSpec.push(["P","writeUInt32LE",4]),V.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),V.prototype.fieldSpec.push(["cn0","writeUInt8",1]),V.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),V.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]);var H=function(e,t){return p.call(this,e),this.messageType="MSG_OBS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(H.prototype=Object.create(p.prototype)).messageType="MSG_OBS_DEP_A",H.prototype.msg_type=69,H.prototype.constructor=H,H.prototype.parser=(new o).endianess("little").nest("header",{type:F.prototype.parser}).array("obs",{type:q.prototype.parser,readUntil:"eof"}),H.prototype.fieldSpec=[],H.prototype.fieldSpec.push(["header",F.prototype.fieldSpec]),H.prototype.fieldSpec.push(["obs","array",q.prototype.fieldSpec,function(){return this.fields.array.length},null]);var Y=function(e,t){return p.call(this,e),this.messageType="MSG_OBS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(Y.prototype=Object.create(p.prototype)).messageType="MSG_OBS_DEP_B",Y.prototype.msg_type=67,Y.prototype.constructor=Y,Y.prototype.parser=(new o).endianess("little").nest("header",{type:F.prototype.parser}).array("obs",{type:z.prototype.parser,readUntil:"eof"}),Y.prototype.fieldSpec=[],Y.prototype.fieldSpec.push(["header",F.prototype.fieldSpec]),Y.prototype.fieldSpec.push(["obs","array",z.prototype.fieldSpec,function(){return this.fields.array.length},null]);var W=function(e,t){return p.call(this,e),this.messageType="MSG_OBS_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(W.prototype=Object.create(p.prototype)).messageType="MSG_OBS_DEP_C",W.prototype.msg_type=73,W.prototype.constructor=W,W.prototype.parser=(new o).endianess("little").nest("header",{type:F.prototype.parser}).array("obs",{type:V.prototype.parser,readUntil:"eof"}),W.prototype.fieldSpec=[],W.prototype.fieldSpec.push(["header",F.prototype.fieldSpec]),W.prototype.fieldSpec.push(["obs","array",V.prototype.fieldSpec,function(){return this.fields.array.length},null]);var Q=function(e,t){return p.call(this,e),this.messageType="MSG_IONO",this.fields=t||this.parser.parse(e.payload),this};(Q.prototype=Object.create(p.prototype)).messageType="MSG_IONO",Q.prototype.msg_type=144,Q.prototype.constructor=Q,Q.prototype.parser=(new o).endianess("little").nest("t_nmct",{type:c.prototype.parser}).doublele("a0").doublele("a1").doublele("a2").doublele("a3").doublele("b0").doublele("b1").doublele("b2").doublele("b3"),Q.prototype.fieldSpec=[],Q.prototype.fieldSpec.push(["t_nmct",c.prototype.fieldSpec]),Q.prototype.fieldSpec.push(["a0","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["a1","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["a2","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["a3","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["b0","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["b1","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["b2","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["b3","writeDoubleLE",8]);var K=function(e,t){return p.call(this,e),this.messageType="MSG_SV_CONFIGURATION_GPS_DEP",this.fields=t||this.parser.parse(e.payload),this};(K.prototype=Object.create(p.prototype)).messageType="MSG_SV_CONFIGURATION_GPS_DEP",K.prototype.msg_type=145,K.prototype.constructor=K,K.prototype.parser=(new o).endianess("little").nest("t_nmct",{type:c.prototype.parser}).uint32("l2c_mask"),K.prototype.fieldSpec=[],K.prototype.fieldSpec.push(["t_nmct",c.prototype.fieldSpec]),K.prototype.fieldSpec.push(["l2c_mask","writeUInt32LE",4]);var X=function(e,t){return p.call(this,e),this.messageType="GnssCapb",this.fields=t||this.parser.parse(e.payload),this};(X.prototype=Object.create(p.prototype)).messageType="GnssCapb",X.prototype.constructor=X,X.prototype.parser=(new o).endianess("little").uint64("gps_active").uint64("gps_l2c").uint64("gps_l5").uint32("glo_active").uint32("glo_l2of").uint32("glo_l3").uint64("sbas_active").uint64("sbas_l5").uint64("bds_active").uint64("bds_d2nav").uint64("bds_b2").uint64("bds_b2a").uint32("qzss_active").uint64("gal_active").uint64("gal_e5"),X.prototype.fieldSpec=[],X.prototype.fieldSpec.push(["gps_active","writeUInt64LE",8]),X.prototype.fieldSpec.push(["gps_l2c","writeUInt64LE",8]),X.prototype.fieldSpec.push(["gps_l5","writeUInt64LE",8]),X.prototype.fieldSpec.push(["glo_active","writeUInt32LE",4]),X.prototype.fieldSpec.push(["glo_l2of","writeUInt32LE",4]),X.prototype.fieldSpec.push(["glo_l3","writeUInt32LE",4]),X.prototype.fieldSpec.push(["sbas_active","writeUInt64LE",8]),X.prototype.fieldSpec.push(["sbas_l5","writeUInt64LE",8]),X.prototype.fieldSpec.push(["bds_active","writeUInt64LE",8]),X.prototype.fieldSpec.push(["bds_d2nav","writeUInt64LE",8]),X.prototype.fieldSpec.push(["bds_b2","writeUInt64LE",8]),X.prototype.fieldSpec.push(["bds_b2a","writeUInt64LE",8]),X.prototype.fieldSpec.push(["qzss_active","writeUInt32LE",4]),X.prototype.fieldSpec.push(["gal_active","writeUInt64LE",8]),X.prototype.fieldSpec.push(["gal_e5","writeUInt64LE",8]);var J=function(e,t){return p.call(this,e),this.messageType="MSG_GNSS_CAPB",this.fields=t||this.parser.parse(e.payload),this};(J.prototype=Object.create(p.prototype)).messageType="MSG_GNSS_CAPB",J.prototype.msg_type=150,J.prototype.constructor=J,J.prototype.parser=(new o).endianess("little").nest("t_nmct",{type:c.prototype.parser}).nest("gc",{type:X.prototype.parser}),J.prototype.fieldSpec=[],J.prototype.fieldSpec.push(["t_nmct",c.prototype.fieldSpec]),J.prototype.fieldSpec.push(["gc",X.prototype.fieldSpec]);var $=function(e,t){return p.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_A",this.fields=t||this.parser.parse(e.payload),this};($.prototype=Object.create(p.prototype)).messageType="MSG_GROUP_DELAY_DEP_A",$.prototype.msg_type=146,$.prototype.constructor=$,$.prototype.parser=(new o).endianess("little").nest("t_op",{type:l.prototype.parser}).uint8("prn").uint8("valid").int16("tgd").int16("isc_l1ca").int16("isc_l2c"),$.prototype.fieldSpec=[],$.prototype.fieldSpec.push(["t_op",l.prototype.fieldSpec]),$.prototype.fieldSpec.push(["prn","writeUInt8",1]),$.prototype.fieldSpec.push(["valid","writeUInt8",1]),$.prototype.fieldSpec.push(["tgd","writeInt16LE",2]),$.prototype.fieldSpec.push(["isc_l1ca","writeInt16LE",2]),$.prototype.fieldSpec.push(["isc_l2c","writeInt16LE",2]);var Z=function(e,t){return p.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(Z.prototype=Object.create(p.prototype)).messageType="MSG_GROUP_DELAY_DEP_B",Z.prototype.msg_type=147,Z.prototype.constructor=Z,Z.prototype.parser=(new o).endianess("little").nest("t_op",{type:c.prototype.parser}).nest("sid",{type:n.prototype.parser}).uint8("valid").int16("tgd").int16("isc_l1ca").int16("isc_l2c"),Z.prototype.fieldSpec=[],Z.prototype.fieldSpec.push(["t_op",c.prototype.fieldSpec]),Z.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),Z.prototype.fieldSpec.push(["valid","writeUInt8",1]),Z.prototype.fieldSpec.push(["tgd","writeInt16LE",2]),Z.prototype.fieldSpec.push(["isc_l1ca","writeInt16LE",2]),Z.prototype.fieldSpec.push(["isc_l2c","writeInt16LE",2]);var ee=function(e,t){return p.call(this,e),this.messageType="MSG_GROUP_DELAY",this.fields=t||this.parser.parse(e.payload),this};(ee.prototype=Object.create(p.prototype)).messageType="MSG_GROUP_DELAY",ee.prototype.msg_type=148,ee.prototype.constructor=ee,ee.prototype.parser=(new o).endianess("little").nest("t_op",{type:c.prototype.parser}).nest("sid",{type:s.prototype.parser}).uint8("valid").int16("tgd").int16("isc_l1ca").int16("isc_l2c"),ee.prototype.fieldSpec=[],ee.prototype.fieldSpec.push(["t_op",c.prototype.fieldSpec]),ee.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),ee.prototype.fieldSpec.push(["valid","writeUInt8",1]),ee.prototype.fieldSpec.push(["tgd","writeInt16LE",2]),ee.prototype.fieldSpec.push(["isc_l1ca","writeInt16LE",2]),ee.prototype.fieldSpec.push(["isc_l2c","writeInt16LE",2]);var te=function(e,t){return p.call(this,e),this.messageType="AlmanacCommonContent",this.fields=t||this.parser.parse(e.payload),this};(te.prototype=Object.create(p.prototype)).messageType="AlmanacCommonContent",te.prototype.constructor=te,te.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).nest("toa",{type:c.prototype.parser}).doublele("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),te.prototype.fieldSpec=[],te.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),te.prototype.fieldSpec.push(["toa",c.prototype.fieldSpec]),te.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),te.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),te.prototype.fieldSpec.push(["valid","writeUInt8",1]),te.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);var re=function(e,t){return p.call(this,e),this.messageType="AlmanacCommonContentDep",this.fields=t||this.parser.parse(e.payload),this};(re.prototype=Object.create(p.prototype)).messageType="AlmanacCommonContentDep",re.prototype.constructor=re,re.prototype.parser=(new o).endianess("little").nest("sid",{type:n.prototype.parser}).nest("toa",{type:c.prototype.parser}).doublele("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),re.prototype.fieldSpec=[],re.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),re.prototype.fieldSpec.push(["toa",c.prototype.fieldSpec]),re.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),re.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),re.prototype.fieldSpec.push(["valid","writeUInt8",1]),re.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);var pe=function(e,t){return p.call(this,e),this.messageType="MSG_ALMANAC_GPS_DEP",this.fields=t||this.parser.parse(e.payload),this};(pe.prototype=Object.create(p.prototype)).messageType="MSG_ALMANAC_GPS_DEP",pe.prototype.msg_type=112,pe.prototype.constructor=pe,pe.prototype.parser=(new o).endianess("little").nest("common",{type:re.prototype.parser}).doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("af0").doublele("af1"),pe.prototype.fieldSpec=[],pe.prototype.fieldSpec.push(["common",re.prototype.fieldSpec]),pe.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["w","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["af1","writeDoubleLE",8]);var oe=function(e,t){return p.call(this,e),this.messageType="MSG_ALMANAC_GPS",this.fields=t||this.parser.parse(e.payload),this};(oe.prototype=Object.create(p.prototype)).messageType="MSG_ALMANAC_GPS",oe.prototype.msg_type=114,oe.prototype.constructor=oe,oe.prototype.parser=(new o).endianess("little").nest("common",{type:te.prototype.parser}).doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("af0").doublele("af1"),oe.prototype.fieldSpec=[],oe.prototype.fieldSpec.push(["common",te.prototype.fieldSpec]),oe.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["w","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["af1","writeDoubleLE",8]);var ie=function(e,t){return p.call(this,e),this.messageType="MSG_ALMANAC_GLO_DEP",this.fields=t||this.parser.parse(e.payload),this};(ie.prototype=Object.create(p.prototype)).messageType="MSG_ALMANAC_GLO_DEP",ie.prototype.msg_type=113,ie.prototype.constructor=ie,ie.prototype.parser=(new o).endianess("little").nest("common",{type:re.prototype.parser}).doublele("lambda_na").doublele("t_lambda_na").doublele("i").doublele("t").doublele("t_dot").doublele("epsilon").doublele("omega"),ie.prototype.fieldSpec=[],ie.prototype.fieldSpec.push(["common",re.prototype.fieldSpec]),ie.prototype.fieldSpec.push(["lambda_na","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["t_lambda_na","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["i","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["t","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["t_dot","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["epsilon","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["omega","writeDoubleLE",8]);var se=function(e,t){return p.call(this,e),this.messageType="MSG_ALMANAC_GLO",this.fields=t||this.parser.parse(e.payload),this};(se.prototype=Object.create(p.prototype)).messageType="MSG_ALMANAC_GLO",se.prototype.msg_type=115,se.prototype.constructor=se,se.prototype.parser=(new o).endianess("little").nest("common",{type:te.prototype.parser}).doublele("lambda_na").doublele("t_lambda_na").doublele("i").doublele("t").doublele("t_dot").doublele("epsilon").doublele("omega"),se.prototype.fieldSpec=[],se.prototype.fieldSpec.push(["common",te.prototype.fieldSpec]),se.prototype.fieldSpec.push(["lambda_na","writeDoubleLE",8]),se.prototype.fieldSpec.push(["t_lambda_na","writeDoubleLE",8]),se.prototype.fieldSpec.push(["i","writeDoubleLE",8]),se.prototype.fieldSpec.push(["t","writeDoubleLE",8]),se.prototype.fieldSpec.push(["t_dot","writeDoubleLE",8]),se.prototype.fieldSpec.push(["epsilon","writeDoubleLE",8]),se.prototype.fieldSpec.push(["omega","writeDoubleLE",8]);var ne=function(e,t){return p.call(this,e),this.messageType="MSG_GLO_BIASES",this.fields=t||this.parser.parse(e.payload),this};(ne.prototype=Object.create(p.prototype)).messageType="MSG_GLO_BIASES",ne.prototype.msg_type=117,ne.prototype.constructor=ne,ne.prototype.parser=(new o).endianess("little").uint8("mask").int16("l1ca_bias").int16("l1p_bias").int16("l2ca_bias").int16("l2p_bias"),ne.prototype.fieldSpec=[],ne.prototype.fieldSpec.push(["mask","writeUInt8",1]),ne.prototype.fieldSpec.push(["l1ca_bias","writeInt16LE",2]),ne.prototype.fieldSpec.push(["l1p_bias","writeInt16LE",2]),ne.prototype.fieldSpec.push(["l2ca_bias","writeInt16LE",2]),ne.prototype.fieldSpec.push(["l2p_bias","writeInt16LE",2]);var ae=function(e,t){return p.call(this,e),this.messageType="SvAzEl",this.fields=t||this.parser.parse(e.payload),this};(ae.prototype=Object.create(p.prototype)).messageType="SvAzEl",ae.prototype.constructor=ae,ae.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).uint8("az").int8("el"),ae.prototype.fieldSpec=[],ae.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),ae.prototype.fieldSpec.push(["az","writeUInt8",1]),ae.prototype.fieldSpec.push(["el","writeInt8",1]);var le=function(e,t){return p.call(this,e),this.messageType="MSG_SV_AZ_EL",this.fields=t||this.parser.parse(e.payload),this};(le.prototype=Object.create(p.prototype)).messageType="MSG_SV_AZ_EL",le.prototype.msg_type=151,le.prototype.constructor=le,le.prototype.parser=(new o).endianess("little").array("azel",{type:ae.prototype.parser,readUntil:"eof"}),le.prototype.fieldSpec=[],le.prototype.fieldSpec.push(["azel","array",ae.prototype.fieldSpec,function(){return this.fields.array.length},null]);var ce=function(e,t){return p.call(this,e),this.messageType="MSG_OSR",this.fields=t||this.parser.parse(e.payload),this};(ce.prototype=Object.create(p.prototype)).messageType="MSG_OSR",ce.prototype.msg_type=1600,ce.prototype.constructor=ce,ce.prototype.parser=(new o).endianess("little").nest("header",{type:u.prototype.parser}).array("obs",{type:f.prototype.parser,readUntil:"eof"}),ce.prototype.fieldSpec=[],ce.prototype.fieldSpec.push(["header",u.prototype.fieldSpec]),ce.prototype.fieldSpec.push(["obs","array",f.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={ObservationHeader:u,Doppler:y,PackedObsContent:h,PackedOsrContent:f,74:d,MsgObs:d,68:_,MsgBasePosLlh:_,72:S,MsgBasePosEcef:S,EphemerisCommonContent:g,EphemerisCommonContentDepB:w,EphemerisCommonContentDepA:E,129:m,MsgEphemerisGpsDepE:m,134:b,MsgEphemerisGpsDepF:b,138:v,MsgEphemerisGps:v,142:L,MsgEphemerisQzss:L,137:I,MsgEphemerisBds:I,149:T,MsgEphemerisGalDepA:T,141:U,MsgEphemerisGal:U,130:M,MsgEphemerisSbasDepA:M,131:D,MsgEphemerisGloDepA:D,132:O,MsgEphemerisSbasDepB:O,140:G,MsgEphemerisSbas:G,133:A,MsgEphemerisGloDepB:A,135:C,MsgEphemerisGloDepC:C,136:R,MsgEphemerisGloDepD:R,139:P,MsgEphemerisGlo:P,128:N,MsgEphemerisDepD:N,26:j,MsgEphemerisDepA:j,70:x,MsgEphemerisDepB:x,71:k,MsgEphemerisDepC:k,ObservationHeaderDep:F,CarrierPhaseDepA:B,PackedObsContentDepA:q,PackedObsContentDepB:z,PackedObsContentDepC:V,69:H,MsgObsDepA:H,67:Y,MsgObsDepB:Y,73:W,MsgObsDepC:W,144:Q,MsgIono:Q,145:K,MsgSvConfigurationGpsDep:K,GnssCapb:X,150:J,MsgGnssCapb:J,146:$,MsgGroupDelayDepA:$,147:Z,MsgGroupDelayDepB:Z,148:ee,MsgGroupDelay:ee,AlmanacCommonContent:te,AlmanacCommonContentDep:re,112:pe,MsgAlmanacGpsDep:pe,114:oe,MsgAlmanacGps:oe,113:ie,MsgAlmanacGloDep:ie,115:se,MsgAlmanacGlo:se,117:ne,MsgGloBiases:ne,SvAzEl:ae,151:le,MsgSvAzEl:le,1600:ce,MsgOsr:ce}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_BASELINE_HEADING",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_BASELINE_HEADING",i.prototype.msg_type=527,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("tow").uint32("heading").uint8("n_sats").uint8("flags"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["heading","writeUInt32LE",4]),i.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_ORIENT_QUAT",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_ORIENT_QUAT",s.prototype.msg_type=544,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint32("tow").int32("w").int32("x").int32("y").int32("z").floatle("w_accuracy").floatle("x_accuracy").floatle("y_accuracy").floatle("z_accuracy").uint8("flags"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["w","writeInt32LE",4]),s.prototype.fieldSpec.push(["x","writeInt32LE",4]),s.prototype.fieldSpec.push(["y","writeInt32LE",4]),s.prototype.fieldSpec.push(["z","writeInt32LE",4]),s.prototype.fieldSpec.push(["w_accuracy","writeFloatLE",4]),s.prototype.fieldSpec.push(["x_accuracy","writeFloatLE",4]),s.prototype.fieldSpec.push(["y_accuracy","writeFloatLE",4]),s.prototype.fieldSpec.push(["z_accuracy","writeFloatLE",4]),s.prototype.fieldSpec.push(["flags","writeUInt8",1]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_ORIENT_EULER",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_ORIENT_EULER",n.prototype.msg_type=545,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint32("tow").int32("roll").int32("pitch").int32("yaw").floatle("roll_accuracy").floatle("pitch_accuracy").floatle("yaw_accuracy").uint8("flags"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),n.prototype.fieldSpec.push(["roll","writeInt32LE",4]),n.prototype.fieldSpec.push(["pitch","writeInt32LE",4]),n.prototype.fieldSpec.push(["yaw","writeInt32LE",4]),n.prototype.fieldSpec.push(["roll_accuracy","writeFloatLE",4]),n.prototype.fieldSpec.push(["pitch_accuracy","writeFloatLE",4]),n.prototype.fieldSpec.push(["yaw_accuracy","writeFloatLE",4]),n.prototype.fieldSpec.push(["flags","writeUInt8",1]);var a=function(e,t){return p.call(this,e),this.messageType="MSG_ANGULAR_RATE",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="MSG_ANGULAR_RATE",a.prototype.msg_type=546,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint8("flags"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),a.prototype.fieldSpec.push(["x","writeInt32LE",4]),a.prototype.fieldSpec.push(["y","writeInt32LE",4]),a.prototype.fieldSpec.push(["z","writeInt32LE",4]),a.prototype.fieldSpec.push(["flags","writeUInt8",1]),e.exports={527:i,MsgBaselineHeading:i,544:s,MsgOrientQuat:s,545:n,MsgOrientEuler:n,546:a,MsgAngularRate:a}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,r(0).CarrierPhase,r(0).GnssSignal),s=r(0).GnssSignalDep,n=r(0).GPSTime,a=r(0).GPSTimeDep,l=(r(0).GPSTimeSec,r(0).SvId,function(e,t){return p.call(this,e),this.messageType="MSG_ALMANAC",this.fields=t||this.parser.parse(e.payload),this});(l.prototype=Object.create(p.prototype)).messageType="MSG_ALMANAC",l.prototype.msg_type=105,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little"),l.prototype.fieldSpec=[];var c=function(e,t){return p.call(this,e),this.messageType="MSG_SET_TIME",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="MSG_SET_TIME",c.prototype.msg_type=104,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little"),c.prototype.fieldSpec=[];var u=function(e,t){return p.call(this,e),this.messageType="MSG_RESET",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="MSG_RESET",u.prototype.msg_type=182,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("flags"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);var y=function(e,t){return p.call(this,e),this.messageType="MSG_RESET_DEP",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="MSG_RESET_DEP",y.prototype.msg_type=178,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little"),y.prototype.fieldSpec=[];var h=function(e,t){return p.call(this,e),this.messageType="MSG_CW_RESULTS",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_CW_RESULTS",h.prototype.msg_type=192,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little"),h.prototype.fieldSpec=[];var f=function(e,t){return p.call(this,e),this.messageType="MSG_CW_START",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="MSG_CW_START",f.prototype.msg_type=193,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little"),f.prototype.fieldSpec=[];var d=function(e,t){return p.call(this,e),this.messageType="MSG_RESET_FILTERS",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(p.prototype)).messageType="MSG_RESET_FILTERS",d.prototype.msg_type=34,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint8("filter"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["filter","writeUInt8",1]);var _=function(e,t){return p.call(this,e),this.messageType="MSG_INIT_BASE_DEP",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(p.prototype)).messageType="MSG_INIT_BASE_DEP",_.prototype.msg_type=35,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little"),_.prototype.fieldSpec=[];var S=function(e,t){return p.call(this,e),this.messageType="MSG_THREAD_STATE",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(p.prototype)).messageType="MSG_THREAD_STATE",S.prototype.msg_type=23,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").string("name",{length:20}).uint16("cpu").uint32("stack_free"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["name","string",20]),S.prototype.fieldSpec.push(["cpu","writeUInt16LE",2]),S.prototype.fieldSpec.push(["stack_free","writeUInt32LE",4]);var g=function(e,t){return p.call(this,e),this.messageType="UARTChannel",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(p.prototype)).messageType="UARTChannel",g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").floatle("tx_throughput").floatle("rx_throughput").uint16("crc_error_count").uint16("io_error_count").uint8("tx_buffer_level").uint8("rx_buffer_level"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["tx_throughput","writeFloatLE",4]),g.prototype.fieldSpec.push(["rx_throughput","writeFloatLE",4]),g.prototype.fieldSpec.push(["crc_error_count","writeUInt16LE",2]),g.prototype.fieldSpec.push(["io_error_count","writeUInt16LE",2]),g.prototype.fieldSpec.push(["tx_buffer_level","writeUInt8",1]),g.prototype.fieldSpec.push(["rx_buffer_level","writeUInt8",1]);var w=function(e,t){return p.call(this,e),this.messageType="Period",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(p.prototype)).messageType="Period",w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").int32("avg").int32("pmin").int32("pmax").int32("current"),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["avg","writeInt32LE",4]),w.prototype.fieldSpec.push(["pmin","writeInt32LE",4]),w.prototype.fieldSpec.push(["pmax","writeInt32LE",4]),w.prototype.fieldSpec.push(["current","writeInt32LE",4]);var E=function(e,t){return p.call(this,e),this.messageType="Latency",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(p.prototype)).messageType="Latency",E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").int32("avg").int32("lmin").int32("lmax").int32("current"),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["avg","writeInt32LE",4]),E.prototype.fieldSpec.push(["lmin","writeInt32LE",4]),E.prototype.fieldSpec.push(["lmax","writeInt32LE",4]),E.prototype.fieldSpec.push(["current","writeInt32LE",4]);var m=function(e,t){return p.call(this,e),this.messageType="MSG_UART_STATE",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(p.prototype)).messageType="MSG_UART_STATE",m.prototype.msg_type=29,m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").nest("uart_a",{type:g.prototype.parser}).nest("uart_b",{type:g.prototype.parser}).nest("uart_ftdi",{type:g.prototype.parser}).nest("latency",{type:E.prototype.parser}).nest("obs_period",{type:w.prototype.parser}),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["uart_a",g.prototype.fieldSpec]),m.prototype.fieldSpec.push(["uart_b",g.prototype.fieldSpec]),m.prototype.fieldSpec.push(["uart_ftdi",g.prototype.fieldSpec]),m.prototype.fieldSpec.push(["latency",E.prototype.fieldSpec]),m.prototype.fieldSpec.push(["obs_period",w.prototype.fieldSpec]);var b=function(e,t){return p.call(this,e),this.messageType="MSG_UART_STATE_DEPA",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(p.prototype)).messageType="MSG_UART_STATE_DEPA",b.prototype.msg_type=24,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").nest("uart_a",{type:g.prototype.parser}).nest("uart_b",{type:g.prototype.parser}).nest("uart_ftdi",{type:g.prototype.parser}).nest("latency",{type:E.prototype.parser}),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["uart_a",g.prototype.fieldSpec]),b.prototype.fieldSpec.push(["uart_b",g.prototype.fieldSpec]),b.prototype.fieldSpec.push(["uart_ftdi",g.prototype.fieldSpec]),b.prototype.fieldSpec.push(["latency",E.prototype.fieldSpec]);var v=function(e,t){return p.call(this,e),this.messageType="MSG_IAR_STATE",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(p.prototype)).messageType="MSG_IAR_STATE",v.prototype.msg_type=25,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").uint32("num_hyps"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["num_hyps","writeUInt32LE",4]);var L=function(e,t){return p.call(this,e),this.messageType="MSG_MASK_SATELLITE",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(p.prototype)).messageType="MSG_MASK_SATELLITE",L.prototype.msg_type=43,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").uint8("mask").nest("sid",{type:i.prototype.parser}),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["mask","writeUInt8",1]),L.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]);var I=function(e,t){return p.call(this,e),this.messageType="MSG_MASK_SATELLITE_DEP",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(p.prototype)).messageType="MSG_MASK_SATELLITE_DEP",I.prototype.msg_type=27,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").uint8("mask").nest("sid",{type:s.prototype.parser}),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["mask","writeUInt8",1]),I.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);var T=function(e,t){return p.call(this,e),this.messageType="MSG_DEVICE_MONITOR",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(p.prototype)).messageType="MSG_DEVICE_MONITOR",T.prototype.msg_type=181,T.prototype.constructor=T,T.prototype.parser=(new o).endianess("little").int16("dev_vin").int16("cpu_vint").int16("cpu_vaux").int16("cpu_temperature").int16("fe_temperature"),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["dev_vin","writeInt16LE",2]),T.prototype.fieldSpec.push(["cpu_vint","writeInt16LE",2]),T.prototype.fieldSpec.push(["cpu_vaux","writeInt16LE",2]),T.prototype.fieldSpec.push(["cpu_temperature","writeInt16LE",2]),T.prototype.fieldSpec.push(["fe_temperature","writeInt16LE",2]);var U=function(e,t){return p.call(this,e),this.messageType="MSG_COMMAND_REQ",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(p.prototype)).messageType="MSG_COMMAND_REQ",U.prototype.msg_type=184,U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").uint32("sequence").string("command",{greedy:!0}),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),U.prototype.fieldSpec.push(["command","string",null]);var M=function(e,t){return p.call(this,e),this.messageType="MSG_COMMAND_RESP",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(p.prototype)).messageType="MSG_COMMAND_RESP",M.prototype.msg_type=185,M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").uint32("sequence").int32("code"),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),M.prototype.fieldSpec.push(["code","writeInt32LE",4]);var D=function(e,t){return p.call(this,e),this.messageType="MSG_COMMAND_OUTPUT",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(p.prototype)).messageType="MSG_COMMAND_OUTPUT",D.prototype.msg_type=188,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").uint32("sequence").string("line",{greedy:!0}),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),D.prototype.fieldSpec.push(["line","string",null]);var O=function(e,t){return p.call(this,e),this.messageType="MSG_NETWORK_STATE_REQ",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(p.prototype)).messageType="MSG_NETWORK_STATE_REQ",O.prototype.msg_type=186,O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little"),O.prototype.fieldSpec=[];var G=function(e,t){return p.call(this,e),this.messageType="MSG_NETWORK_STATE_RESP",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(p.prototype)).messageType="MSG_NETWORK_STATE_RESP",G.prototype.msg_type=187,G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").array("ipv4_address",{length:4,type:"uint8"}).uint8("ipv4_mask_size").array("ipv6_address",{length:16,type:"uint8"}).uint8("ipv6_mask_size").uint32("rx_bytes").uint32("tx_bytes").string("interface_name",{length:16}).uint32("flags"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["ipv4_address","array","writeUInt8",function(){return 1},4]),G.prototype.fieldSpec.push(["ipv4_mask_size","writeUInt8",1]),G.prototype.fieldSpec.push(["ipv6_address","array","writeUInt8",function(){return 1},16]),G.prototype.fieldSpec.push(["ipv6_mask_size","writeUInt8",1]),G.prototype.fieldSpec.push(["rx_bytes","writeUInt32LE",4]),G.prototype.fieldSpec.push(["tx_bytes","writeUInt32LE",4]),G.prototype.fieldSpec.push(["interface_name","string",16]),G.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);var A=function(e,t){return p.call(this,e),this.messageType="NetworkUsage",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(p.prototype)).messageType="NetworkUsage",A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").uint64("duration").uint64("total_bytes").uint32("rx_bytes").uint32("tx_bytes").string("interface_name",{length:16}),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["duration","writeUInt64LE",8]),A.prototype.fieldSpec.push(["total_bytes","writeUInt64LE",8]),A.prototype.fieldSpec.push(["rx_bytes","writeUInt32LE",4]),A.prototype.fieldSpec.push(["tx_bytes","writeUInt32LE",4]),A.prototype.fieldSpec.push(["interface_name","string",16]);var C=function(e,t){return p.call(this,e),this.messageType="MSG_NETWORK_BANDWIDTH_USAGE",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(p.prototype)).messageType="MSG_NETWORK_BANDWIDTH_USAGE",C.prototype.msg_type=189,C.prototype.constructor=C,C.prototype.parser=(new o).endianess("little").array("interfaces",{type:A.prototype.parser,readUntil:"eof"}),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["interfaces","array",A.prototype.fieldSpec,function(){return this.fields.array.length},null]);var R=function(e,t){return p.call(this,e),this.messageType="MSG_CELL_MODEM_STATUS",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(p.prototype)).messageType="MSG_CELL_MODEM_STATUS",R.prototype.msg_type=190,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").int8("signal_strength").floatle("signal_error_rate").array("reserved",{type:"uint8",readUntil:"eof"}),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["signal_strength","writeInt8",1]),R.prototype.fieldSpec.push(["signal_error_rate","writeFloatLE",4]),R.prototype.fieldSpec.push(["reserved","array","writeUInt8",function(){return 1},null]);var P=function(e,t){return p.call(this,e),this.messageType="MSG_SPECAN_DEP",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(p.prototype)).messageType="MSG_SPECAN_DEP",P.prototype.msg_type=80,P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").uint16("channel_tag").nest("t",{type:a.prototype.parser}).floatle("freq_ref").floatle("freq_step").floatle("amplitude_ref").floatle("amplitude_unit").array("amplitude_value",{type:"uint8",readUntil:"eof"}),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["channel_tag","writeUInt16LE",2]),P.prototype.fieldSpec.push(["t",a.prototype.fieldSpec]),P.prototype.fieldSpec.push(["freq_ref","writeFloatLE",4]),P.prototype.fieldSpec.push(["freq_step","writeFloatLE",4]),P.prototype.fieldSpec.push(["amplitude_ref","writeFloatLE",4]),P.prototype.fieldSpec.push(["amplitude_unit","writeFloatLE",4]),P.prototype.fieldSpec.push(["amplitude_value","array","writeUInt8",function(){return 1},null]);var N=function(e,t){return p.call(this,e),this.messageType="MSG_SPECAN",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(p.prototype)).messageType="MSG_SPECAN",N.prototype.msg_type=81,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").uint16("channel_tag").nest("t",{type:n.prototype.parser}).floatle("freq_ref").floatle("freq_step").floatle("amplitude_ref").floatle("amplitude_unit").array("amplitude_value",{type:"uint8",readUntil:"eof"}),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["channel_tag","writeUInt16LE",2]),N.prototype.fieldSpec.push(["t",n.prototype.fieldSpec]),N.prototype.fieldSpec.push(["freq_ref","writeFloatLE",4]),N.prototype.fieldSpec.push(["freq_step","writeFloatLE",4]),N.prototype.fieldSpec.push(["amplitude_ref","writeFloatLE",4]),N.prototype.fieldSpec.push(["amplitude_unit","writeFloatLE",4]),N.prototype.fieldSpec.push(["amplitude_value","array","writeUInt8",function(){return 1},null]);var j=function(e,t){return p.call(this,e),this.messageType="MSG_FRONT_END_GAIN",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(p.prototype)).messageType="MSG_FRONT_END_GAIN",j.prototype.msg_type=191,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").array("rf_gain",{length:8,type:"int8"}).array("if_gain",{length:8,type:"int8"}),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["rf_gain","array","writeInt8",function(){return 1},8]),j.prototype.fieldSpec.push(["if_gain","array","writeInt8",function(){return 1},8]),e.exports={105:l,MsgAlmanac:l,104:c,MsgSetTime:c,182:u,MsgReset:u,178:y,MsgResetDep:y,192:h,MsgCwResults:h,193:f,MsgCwStart:f,34:d,MsgResetFilters:d,35:_,MsgInitBaseDep:_,23:S,MsgThreadState:S,UARTChannel:g,Period:w,Latency:E,29:m,MsgUartState:m,24:b,MsgUartStateDepa:b,25:v,MsgIarState:v,43:L,MsgMaskSatellite:L,27:I,MsgMaskSatelliteDep:I,181:T,MsgDeviceMonitor:T,184:U,MsgCommandReq:U,185:M,MsgCommandResp:M,188:D,MsgCommandOutput:D,186:O,MsgNetworkStateReq:O,187:G,MsgNetworkStateResp:G,NetworkUsage:A,189:C,MsgNetworkBandwidthUsage:C,190:R,MsgCellModemStatus:R,80:P,MsgSpecanDep:P,81:N,MsgSpecan:N,191:j,MsgFrontEndGain:j}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,r(0).CarrierPhase,r(0).GnssSignal),s=(r(0).GnssSignalDep,r(0).GPSTime,r(0).GPSTimeDep,r(0).GPSTimeSec,r(0).SvId,function(e,t){return p.call(this,e),this.messageType="MSG_SBAS_RAW",this.fields=t||this.parser.parse(e.payload),this});(s.prototype=Object.create(p.prototype)).messageType="MSG_SBAS_RAW",s.prototype.msg_type=30583,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").nest("sid",{type:i.prototype.parser}).uint32("tow").uint8("message_type").array("data",{length:27,type:"uint8"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),s.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["message_type","writeUInt8",1]),s.prototype.fieldSpec.push(["data","array","writeUInt8",function(){return 1},27]),e.exports={30583:s,MsgSbasRaw:s}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_SAVE",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_SAVE",i.prototype.msg_type=161,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little"),i.prototype.fieldSpec=[];var s=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_WRITE",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_WRITE",s.prototype.msg_type=160,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["setting","string",null]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_WRITE_RESP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_WRITE_RESP",n.prototype.msg_type=175,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("status").string("setting",{greedy:!0}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["status","writeUInt8",1]),n.prototype.fieldSpec.push(["setting","string",null]);var a=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_READ_REQ",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_READ_REQ",a.prototype.msg_type=164,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["setting","string",null]);var l=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_READ_RESP",l.prototype.msg_type=165,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["setting","string",null]);var c=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_REQ",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_READ_BY_INDEX_REQ",c.prototype.msg_type=162,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint16("index"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["index","writeUInt16LE",2]);var u=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_RESP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_READ_BY_INDEX_RESP",u.prototype.msg_type=167,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint16("index").string("setting",{greedy:!0}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["index","writeUInt16LE",2]),u.prototype.fieldSpec.push(["setting","string",null]);var y=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_DONE",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_READ_BY_INDEX_DONE",y.prototype.msg_type=166,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little"),y.prototype.fieldSpec=[];var h=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_REGISTER",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_REGISTER",h.prototype.msg_type=174,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["setting","string",null]);var f=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_REGISTER_RESP",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_REGISTER_RESP",f.prototype.msg_type=431,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("status").string("setting",{greedy:!0}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["status","writeUInt8",1]),f.prototype.fieldSpec.push(["setting","string",null]),e.exports={161:i,MsgSettingsSave:i,160:s,MsgSettingsWrite:s,175:n,MsgSettingsWriteResp:n,164:a,MsgSettingsReadReq:a,165:l,MsgSettingsReadResp:l,162:c,MsgSettingsReadByIndexReq:c,167:u,MsgSettingsReadByIndexResp:u,166:y,MsgSettingsReadByIndexDone:y,174:h,MsgSettingsRegister:h,431:f,MsgSettingsRegisterResp:f}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="SolutionInputType",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="SolutionInputType",i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("sensor_type").uint8("flags"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["sensor_type","writeUInt8",1]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_SOLN_META_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_SOLN_META_DEP_A",s.prototype.msg_type=65295,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint16("pdop").uint16("hdop").uint16("vdop").uint8("n_sats").uint16("age_corrections").uint8("alignment_status").uint32("last_used_gnss_pos_tow").uint32("last_used_gnss_vel_tow").array("sol_in",{type:i.prototype.parser,readUntil:"eof"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),s.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),s.prototype.fieldSpec.push(["vdop","writeUInt16LE",2]),s.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),s.prototype.fieldSpec.push(["age_corrections","writeUInt16LE",2]),s.prototype.fieldSpec.push(["alignment_status","writeUInt8",1]),s.prototype.fieldSpec.push(["last_used_gnss_pos_tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["last_used_gnss_vel_tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["sol_in","array",i.prototype.fieldSpec,function(){return this.fields.array.length},null]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_SOLN_META",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_SOLN_META",n.prototype.msg_type=65294,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint32("tow").uint16("pdop").uint16("hdop").uint16("vdop").uint16("age_corrections").uint32("age_gnss").array("sol_in",{type:i.prototype.parser,readUntil:"eof"}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),n.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),n.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),n.prototype.fieldSpec.push(["vdop","writeUInt16LE",2]),n.prototype.fieldSpec.push(["age_corrections","writeUInt16LE",2]),n.prototype.fieldSpec.push(["age_gnss","writeUInt32LE",4]),n.prototype.fieldSpec.push(["sol_in","array",i.prototype.fieldSpec,function(){return this.fields.array.length},null]);var a=function(e,t){return p.call(this,e),this.messageType="GNSSInputType",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="GNSSInputType",a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("flags"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["flags","writeUInt8",1]);var l=function(e,t){return p.call(this,e),this.messageType="IMUInputType",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="IMUInputType",l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("flags"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["flags","writeUInt8",1]);var c=function(e,t){return p.call(this,e),this.messageType="OdoInputType",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="OdoInputType",c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint8("flags"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["flags","writeUInt8",1]),e.exports={SolutionInputType:i,65295:s,MsgSolnMetaDepA:s,65294:n,MsgSolnMeta:n,GNSSInputType:a,IMUInputType:l,OdoInputType:c}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,r(0).CarrierPhase,r(0).GnssSignal),s=(r(0).GnssSignalDep,r(0).GPSTime,r(0).GPSTimeDep,r(0).GPSTimeSec),n=r(0).SvId,a=function(e,t){return p.call(this,e),this.messageType="CodeBiasesContent",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="CodeBiasesContent",a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("code").int16("value"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["code","writeUInt8",1]),a.prototype.fieldSpec.push(["value","writeInt16LE",2]);var l=function(e,t){return p.call(this,e),this.messageType="PhaseBiasesContent",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="PhaseBiasesContent",l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("code").uint8("integer_indicator").uint8("widelane_integer_indicator").uint8("discontinuity_counter").int32("bias"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["code","writeUInt8",1]),l.prototype.fieldSpec.push(["integer_indicator","writeUInt8",1]),l.prototype.fieldSpec.push(["widelane_integer_indicator","writeUInt8",1]),l.prototype.fieldSpec.push(["discontinuity_counter","writeUInt8",1]),l.prototype.fieldSpec.push(["bias","writeInt32LE",4]);var c=function(e,t){return p.call(this,e),this.messageType="STECHeader",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="STECHeader",c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint16("tile_set_id").uint16("tile_id").nest("time",{type:s.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("update_interval").uint8("iod_atmo"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),c.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),c.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),c.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),c.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),c.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),c.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]);var u=function(e,t){return p.call(this,e),this.messageType="GriddedCorrectionHeader",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="GriddedCorrectionHeader",u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint16("tile_set_id").uint16("tile_id").nest("time",{type:s.prototype.parser}).uint16("num_msgs").uint16("seq_num").uint8("update_interval").uint8("iod_atmo").uint8("tropo_quality_indicator"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),u.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),u.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),u.prototype.fieldSpec.push(["num_msgs","writeUInt16LE",2]),u.prototype.fieldSpec.push(["seq_num","writeUInt16LE",2]),u.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),u.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]),u.prototype.fieldSpec.push(["tropo_quality_indicator","writeUInt8",1]);var y=function(e,t){return p.call(this,e),this.messageType="STECSatElement",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="STECSatElement",y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").nest("sv_id",{type:n.prototype.parser}).uint8("stec_quality_indicator").array("stec_coeff",{length:4,type:"int16le"}),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["sv_id",n.prototype.fieldSpec]),y.prototype.fieldSpec.push(["stec_quality_indicator","writeUInt8",1]),y.prototype.fieldSpec.push(["stec_coeff","array","writeInt16LE",function(){return 2},4]);var h=function(e,t){return p.call(this,e),this.messageType="TroposphericDelayCorrectionNoStd",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="TroposphericDelayCorrectionNoStd",h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").int16("hydro").int8("wet"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["hydro","writeInt16LE",2]),h.prototype.fieldSpec.push(["wet","writeInt8",1]);var f=function(e,t){return p.call(this,e),this.messageType="TroposphericDelayCorrection",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="TroposphericDelayCorrection",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").int16("hydro").int8("wet").uint8("stddev"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["hydro","writeInt16LE",2]),f.prototype.fieldSpec.push(["wet","writeInt8",1]),f.prototype.fieldSpec.push(["stddev","writeUInt8",1]);var d=function(e,t){return p.call(this,e),this.messageType="STECResidualNoStd",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(p.prototype)).messageType="STECResidualNoStd",d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").nest("sv_id",{type:n.prototype.parser}).int16("residual"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["sv_id",n.prototype.fieldSpec]),d.prototype.fieldSpec.push(["residual","writeInt16LE",2]);var _=function(e,t){return p.call(this,e),this.messageType="STECResidual",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(p.prototype)).messageType="STECResidual",_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").nest("sv_id",{type:n.prototype.parser}).int16("residual").uint8("stddev"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["sv_id",n.prototype.fieldSpec]),_.prototype.fieldSpec.push(["residual","writeInt16LE",2]),_.prototype.fieldSpec.push(["stddev","writeUInt8",1]);var S=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(p.prototype)).messageType="MSG_SSR_ORBIT_CLOCK",S.prototype.msg_type=1501,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).nest("sid",{type:i.prototype.parser}).uint8("update_interval").uint8("iod_ssr").uint32("iod").int32("radial").int32("along").int32("cross").int32("dot_radial").int32("dot_along").int32("dot_cross").int32("c0").int32("c1").int32("c2"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),S.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),S.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),S.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),S.prototype.fieldSpec.push(["iod","writeUInt32LE",4]),S.prototype.fieldSpec.push(["radial","writeInt32LE",4]),S.prototype.fieldSpec.push(["along","writeInt32LE",4]),S.prototype.fieldSpec.push(["cross","writeInt32LE",4]),S.prototype.fieldSpec.push(["dot_radial","writeInt32LE",4]),S.prototype.fieldSpec.push(["dot_along","writeInt32LE",4]),S.prototype.fieldSpec.push(["dot_cross","writeInt32LE",4]),S.prototype.fieldSpec.push(["c0","writeInt32LE",4]),S.prototype.fieldSpec.push(["c1","writeInt32LE",4]),S.prototype.fieldSpec.push(["c2","writeInt32LE",4]);var g=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_CODE_BIASES",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(p.prototype)).messageType="MSG_SSR_CODE_BIASES",g.prototype.msg_type=1505,g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).nest("sid",{type:i.prototype.parser}).uint8("update_interval").uint8("iod_ssr").array("biases",{type:a.prototype.parser,readUntil:"eof"}),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),g.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),g.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),g.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),g.prototype.fieldSpec.push(["biases","array",a.prototype.fieldSpec,function(){return this.fields.array.length},null]);var w=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_PHASE_BIASES",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(p.prototype)).messageType="MSG_SSR_PHASE_BIASES",w.prototype.msg_type=1510,w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).nest("sid",{type:i.prototype.parser}).uint8("update_interval").uint8("iod_ssr").uint8("dispersive_bias").uint8("mw_consistency").uint16("yaw").int8("yaw_rate").array("biases",{type:l.prototype.parser,readUntil:"eof"}),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),w.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),w.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),w.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),w.prototype.fieldSpec.push(["dispersive_bias","writeUInt8",1]),w.prototype.fieldSpec.push(["mw_consistency","writeUInt8",1]),w.prototype.fieldSpec.push(["yaw","writeUInt16LE",2]),w.prototype.fieldSpec.push(["yaw_rate","writeInt8",1]),w.prototype.fieldSpec.push(["biases","array",l.prototype.fieldSpec,function(){return this.fields.array.length},null]);var E=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_STEC_CORRECTION",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(p.prototype)).messageType="MSG_SSR_STEC_CORRECTION",E.prototype.msg_type=1531,E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").nest("header",{type:c.prototype.parser}).array("stec_sat_list",{type:y.prototype.parser,readUntil:"eof"}),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["header",c.prototype.fieldSpec]),E.prototype.fieldSpec.push(["stec_sat_list","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);var m=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(p.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION",m.prototype.msg_type=1532,m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").nest("header",{type:u.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:f.prototype.parser}).array("stec_residuals",{type:_.prototype.parser,readUntil:"eof"}),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["header",u.prototype.fieldSpec]),m.prototype.fieldSpec.push(["index","writeUInt16LE",2]),m.prototype.fieldSpec.push(["tropo_delay_correction",f.prototype.fieldSpec]),m.prototype.fieldSpec.push(["stec_residuals","array",_.prototype.fieldSpec,function(){return this.fields.array.length},null]);var b=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_TILE_DEFINITION",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(p.prototype)).messageType="MSG_SSR_TILE_DEFINITION",b.prototype.msg_type=1526,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").uint16("tile_set_id").uint16("tile_id").int16("corner_nw_lat").int16("corner_nw_lon").uint16("spacing_lat").uint16("spacing_lon").uint16("rows").uint16("cols").uint64("bitmask"),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),b.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),b.prototype.fieldSpec.push(["corner_nw_lat","writeInt16LE",2]),b.prototype.fieldSpec.push(["corner_nw_lon","writeInt16LE",2]),b.prototype.fieldSpec.push(["spacing_lat","writeUInt16LE",2]),b.prototype.fieldSpec.push(["spacing_lon","writeUInt16LE",2]),b.prototype.fieldSpec.push(["rows","writeUInt16LE",2]),b.prototype.fieldSpec.push(["cols","writeUInt16LE",2]),b.prototype.fieldSpec.push(["bitmask","writeUInt64LE",8]);var v=function(e,t){return p.call(this,e),this.messageType="SatelliteAPC",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(p.prototype)).messageType="SatelliteAPC",v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").nest("sid",{type:i.prototype.parser}).uint8("sat_info").uint16("svn").array("pco",{length:3,type:"int16le"}).array("pcv",{length:21,type:"int8"}),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),v.prototype.fieldSpec.push(["sat_info","writeUInt8",1]),v.prototype.fieldSpec.push(["svn","writeUInt16LE",2]),v.prototype.fieldSpec.push(["pco","array","writeInt16LE",function(){return 2},3]),v.prototype.fieldSpec.push(["pcv","array","writeInt8",function(){return 1},21]);var L=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_SATELLITE_APC",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(p.prototype)).messageType="MSG_SSR_SATELLITE_APC",L.prototype.msg_type=1540,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").array("apc",{type:v.prototype.parser,readUntil:"eof"}),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["apc","array",v.prototype.fieldSpec,function(){return this.fields.array.length},null]);var I=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(p.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_DEP_A",I.prototype.msg_type=1500,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).nest("sid",{type:i.prototype.parser}).uint8("update_interval").uint8("iod_ssr").uint8("iod").int32("radial").int32("along").int32("cross").int32("dot_radial").int32("dot_along").int32("dot_cross").int32("c0").int32("c1").int32("c2"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),I.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),I.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),I.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),I.prototype.fieldSpec.push(["iod","writeUInt8",1]),I.prototype.fieldSpec.push(["radial","writeInt32LE",4]),I.prototype.fieldSpec.push(["along","writeInt32LE",4]),I.prototype.fieldSpec.push(["cross","writeInt32LE",4]),I.prototype.fieldSpec.push(["dot_radial","writeInt32LE",4]),I.prototype.fieldSpec.push(["dot_along","writeInt32LE",4]),I.prototype.fieldSpec.push(["dot_cross","writeInt32LE",4]),I.prototype.fieldSpec.push(["c0","writeInt32LE",4]),I.prototype.fieldSpec.push(["c1","writeInt32LE",4]),I.prototype.fieldSpec.push(["c2","writeInt32LE",4]);var T=function(e,t){return p.call(this,e),this.messageType="STECHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(p.prototype)).messageType="STECHeaderDepA",T.prototype.constructor=T,T.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("update_interval").uint8("iod_atmo"),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),T.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),T.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),T.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),T.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]);var U=function(e,t){return p.call(this,e),this.messageType="GriddedCorrectionHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(p.prototype)).messageType="GriddedCorrectionHeaderDepA",U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint16("num_msgs").uint16("seq_num").uint8("update_interval").uint8("iod_atmo").uint8("tropo_quality_indicator"),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),U.prototype.fieldSpec.push(["num_msgs","writeUInt16LE",2]),U.prototype.fieldSpec.push(["seq_num","writeUInt16LE",2]),U.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),U.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]),U.prototype.fieldSpec.push(["tropo_quality_indicator","writeUInt8",1]);var M=function(e,t){return p.call(this,e),this.messageType="GridDefinitionHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(p.prototype)).messageType="GridDefinitionHeaderDepA",M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").uint8("region_size_inverse").uint16("area_width").uint16("lat_nw_corner_enc").uint16("lon_nw_corner_enc").uint8("num_msgs").uint8("seq_num"),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["region_size_inverse","writeUInt8",1]),M.prototype.fieldSpec.push(["area_width","writeUInt16LE",2]),M.prototype.fieldSpec.push(["lat_nw_corner_enc","writeUInt16LE",2]),M.prototype.fieldSpec.push(["lon_nw_corner_enc","writeUInt16LE",2]),M.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),M.prototype.fieldSpec.push(["seq_num","writeUInt8",1]);var D=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_STEC_CORRECTION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(p.prototype)).messageType="MSG_SSR_STEC_CORRECTION_DEP_A",D.prototype.msg_type=1515,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").nest("header",{type:T.prototype.parser}).array("stec_sat_list",{type:y.prototype.parser,readUntil:"eof"}),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["header",T.prototype.fieldSpec]),D.prototype.fieldSpec.push(["stec_sat_list","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);var O=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(p.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A",O.prototype.msg_type=1520,O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little").nest("header",{type:U.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:h.prototype.parser}).array("stec_residuals",{type:d.prototype.parser,readUntil:"eof"}),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["header",U.prototype.fieldSpec]),O.prototype.fieldSpec.push(["index","writeUInt16LE",2]),O.prototype.fieldSpec.push(["tropo_delay_correction",h.prototype.fieldSpec]),O.prototype.fieldSpec.push(["stec_residuals","array",d.prototype.fieldSpec,function(){return this.fields.array.length},null]);var G=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(p.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_DEP_A",G.prototype.msg_type=1530,G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").nest("header",{type:U.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:f.prototype.parser}).array("stec_residuals",{type:_.prototype.parser,readUntil:"eof"}),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["header",U.prototype.fieldSpec]),G.prototype.fieldSpec.push(["index","writeUInt16LE",2]),G.prototype.fieldSpec.push(["tropo_delay_correction",f.prototype.fieldSpec]),G.prototype.fieldSpec.push(["stec_residuals","array",_.prototype.fieldSpec,function(){return this.fields.array.length},null]);var A=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_GRID_DEFINITION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(p.prototype)).messageType="MSG_SSR_GRID_DEFINITION_DEP_A",A.prototype.msg_type=1525,A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").nest("header",{type:M.prototype.parser}).array("rle_list",{type:"uint8",readUntil:"eof"}),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["header",M.prototype.fieldSpec]),A.prototype.fieldSpec.push(["rle_list","array","writeUInt8",function(){return 1},null]),e.exports={CodeBiasesContent:a,PhaseBiasesContent:l,STECHeader:c,GriddedCorrectionHeader:u,STECSatElement:y,TroposphericDelayCorrectionNoStd:h,TroposphericDelayCorrection:f,STECResidualNoStd:d,STECResidual:_,1501:S,MsgSsrOrbitClock:S,1505:g,MsgSsrCodeBiases:g,1510:w,MsgSsrPhaseBiases:w,1531:E,MsgSsrStecCorrection:E,1532:m,MsgSsrGriddedCorrection:m,1526:b,MsgSsrTileDefinition:b,SatelliteAPC:v,1540:L,MsgSsrSatelliteApc:L,1500:I,MsgSsrOrbitClockDepA:I,STECHeaderDepA:T,GriddedCorrectionHeaderDepA:U,GridDefinitionHeaderDepA:M,1515:D,MsgSsrStecCorrectionDepA:D,1520:O,MsgSsrGriddedCorrectionNoStdDepA:O,1530:G,MsgSsrGriddedCorrectionDepA:G,1525:A,MsgSsrGridDefinitionDepA:A}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_STARTUP",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_STARTUP",i.prototype.msg_type=65280,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("cause").uint8("startup_type").uint16("reserved"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["cause","writeUInt8",1]),i.prototype.fieldSpec.push(["startup_type","writeUInt8",1]),i.prototype.fieldSpec.push(["reserved","writeUInt16LE",2]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_DGNSS_STATUS",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_DGNSS_STATUS",s.prototype.msg_type=65282,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("flags").uint16("latency").uint8("num_signals").string("source",{greedy:!0}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["flags","writeUInt8",1]),s.prototype.fieldSpec.push(["latency","writeUInt16LE",2]),s.prototype.fieldSpec.push(["num_signals","writeUInt8",1]),s.prototype.fieldSpec.push(["source","string",null]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_HEARTBEAT",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_HEARTBEAT",n.prototype.msg_type=65535,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint32("flags"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);var a=function(e,t){return p.call(this,e),this.messageType="SubSystemReport",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="SubSystemReport",a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint16("component").uint8("generic").uint8("specific"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["component","writeUInt16LE",2]),a.prototype.fieldSpec.push(["generic","writeUInt8",1]),a.prototype.fieldSpec.push(["specific","writeUInt8",1]);var l=function(e,t){return p.call(this,e),this.messageType="MSG_STATUS_REPORT",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="MSG_STATUS_REPORT",l.prototype.msg_type=65534,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint16("reporting_system").uint16("sbp_version").uint32("sequence").uint32("uptime").array("status",{type:a.prototype.parser,readUntil:"eof"}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["reporting_system","writeUInt16LE",2]),l.prototype.fieldSpec.push(["sbp_version","writeUInt16LE",2]),l.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),l.prototype.fieldSpec.push(["uptime","writeUInt32LE",4]),l.prototype.fieldSpec.push(["status","array",a.prototype.fieldSpec,function(){return this.fields.array.length},null]);var c=function(e,t){return p.call(this,e),this.messageType="StatusJournalItem",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="StatusJournalItem",c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("uptime").nest("report",{type:a.prototype.parser}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["uptime","writeUInt32LE",4]),c.prototype.fieldSpec.push(["report",a.prototype.fieldSpec]);var u=function(e,t){return p.call(this,e),this.messageType="MSG_STATUS_JOURNAL",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="MSG_STATUS_JOURNAL",u.prototype.msg_type=65533,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint16("reporting_system").uint16("sbp_version").uint32("total_status_reports").uint8("sequence_descriptor").array("journal",{type:c.prototype.parser,readUntil:"eof"}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["reporting_system","writeUInt16LE",2]),u.prototype.fieldSpec.push(["sbp_version","writeUInt16LE",2]),u.prototype.fieldSpec.push(["total_status_reports","writeUInt32LE",4]),u.prototype.fieldSpec.push(["sequence_descriptor","writeUInt8",1]),u.prototype.fieldSpec.push(["journal","array",c.prototype.fieldSpec,function(){return this.fields.array.length},null]);var y=function(e,t){return p.call(this,e),this.messageType="MSG_INS_STATUS",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="MSG_INS_STATUS",y.prototype.msg_type=65283,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint32("flags"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);var h=function(e,t){return p.call(this,e),this.messageType="MSG_CSAC_TELEMETRY",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_CSAC_TELEMETRY",h.prototype.msg_type=65284,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint8("id").string("telemetry",{greedy:!0}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["id","writeUInt8",1]),h.prototype.fieldSpec.push(["telemetry","string",null]);var f=function(e,t){return p.call(this,e),this.messageType="MSG_CSAC_TELEMETRY_LABELS",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="MSG_CSAC_TELEMETRY_LABELS",f.prototype.msg_type=65285,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("id").string("telemetry_labels",{greedy:!0}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["id","writeUInt8",1]),f.prototype.fieldSpec.push(["telemetry_labels","string",null]);var d=function(e,t){return p.call(this,e),this.messageType="MSG_INS_UPDATES",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(p.prototype)).messageType="MSG_INS_UPDATES",d.prototype.msg_type=65286,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint32("tow").uint8("gnsspos").uint8("gnssvel").uint8("wheelticks").uint8("speed").uint8("nhc").uint8("zerovel"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),d.prototype.fieldSpec.push(["gnsspos","writeUInt8",1]),d.prototype.fieldSpec.push(["gnssvel","writeUInt8",1]),d.prototype.fieldSpec.push(["wheelticks","writeUInt8",1]),d.prototype.fieldSpec.push(["speed","writeUInt8",1]),d.prototype.fieldSpec.push(["nhc","writeUInt8",1]),d.prototype.fieldSpec.push(["zerovel","writeUInt8",1]);var _=function(e,t){return p.call(this,e),this.messageType="MSG_GNSS_TIME_OFFSET",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(p.prototype)).messageType="MSG_GNSS_TIME_OFFSET",_.prototype.msg_type=65287,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").int16("weeks").int32("milliseconds").int16("microseconds").uint8("flags"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["weeks","writeInt16LE",2]),_.prototype.fieldSpec.push(["milliseconds","writeInt32LE",4]),_.prototype.fieldSpec.push(["microseconds","writeInt16LE",2]),_.prototype.fieldSpec.push(["flags","writeUInt8",1]);var S=function(e,t){return p.call(this,e),this.messageType="MSG_PPS_TIME",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(p.prototype)).messageType="MSG_PPS_TIME",S.prototype.msg_type=65288,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").uint64("time").uint8("flags"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["time","writeUInt64LE",8]),S.prototype.fieldSpec.push(["flags","writeUInt8",1]);var g=function(e,t){return p.call(this,e),this.messageType="MSG_SENSOR_AID_EVENT",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(p.prototype)).messageType="MSG_SENSOR_AID_EVENT",g.prototype.msg_type=65289,g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").uint32("time").uint8("sensor_type").uint16("sensor_id").uint8("sensor_state").uint8("n_available_meas").uint8("n_attempted_meas").uint8("n_accepted_meas").uint32("flags"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["time","writeUInt32LE",4]),g.prototype.fieldSpec.push(["sensor_type","writeUInt8",1]),g.prototype.fieldSpec.push(["sensor_id","writeUInt16LE",2]),g.prototype.fieldSpec.push(["sensor_state","writeUInt8",1]),g.prototype.fieldSpec.push(["n_available_meas","writeUInt8",1]),g.prototype.fieldSpec.push(["n_attempted_meas","writeUInt8",1]),g.prototype.fieldSpec.push(["n_accepted_meas","writeUInt8",1]),g.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);var w=function(e,t){return p.call(this,e),this.messageType="MSG_GROUP_META",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(p.prototype)).messageType="MSG_GROUP_META",w.prototype.msg_type=65290,w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").uint8("group_id").uint8("flags").uint8("n_group_msgs").array("group_msgs",{type:"uint16le",length:"n_group_msgs"}),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["group_id","writeUInt8",1]),w.prototype.fieldSpec.push(["flags","writeUInt8",1]),w.prototype.fieldSpec.push(["n_group_msgs","writeUInt8",1]),w.prototype.fieldSpec.push(["group_msgs","array","writeUInt16LE",function(){return 2},"n_group_msgs"]),e.exports={65280:i,MsgStartup:i,65282:s,MsgDgnssStatus:s,65535:n,MsgHeartbeat:n,SubSystemReport:a,65534:l,MsgStatusReport:l,StatusJournalItem:c,65533:u,MsgStatusJournal:u,65283:y,MsgInsStatus:y,65284:h,MsgCsacTelemetry:h,65285:f,MsgCsacTelemetryLabels:f,65286:d,MsgInsUpdates:d,65287:_,MsgGnssTimeOffset:_,65288:S,MsgPpsTime:S,65289:g,MsgSensorAidEvent:g,65290:w,MsgGroupMeta:w}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,r(0).CarrierPhase),s=r(0).GnssSignal,n=r(0).GnssSignalDep,a=r(0).GPSTime,l=r(0).GPSTimeDep,c=(r(0).GPSTimeSec,r(0).SvId,function(e,t){return p.call(this,e),this.messageType="MSG_TRACKING_STATE_DETAILED_DEP_A",this.fields=t||this.parser.parse(e.payload),this});(c.prototype=Object.create(p.prototype)).messageType="MSG_TRACKING_STATE_DETAILED_DEP_A",c.prototype.msg_type=33,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint64("recv_time").nest("tot",{type:a.prototype.parser}).uint32("P").uint16("P_std").nest("L",{type:i.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:s.prototype.parser}).int32("doppler").uint16("doppler_std").uint32("uptime").int16("clock_offset").int16("clock_drift").uint16("corr_spacing").int8("acceleration").uint8("sync_flags").uint8("tow_flags").uint8("track_flags").uint8("nav_flags").uint8("pset_flags").uint8("misc_flags"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["recv_time","writeUInt64LE",8]),c.prototype.fieldSpec.push(["tot",a.prototype.fieldSpec]),c.prototype.fieldSpec.push(["P","writeUInt32LE",4]),c.prototype.fieldSpec.push(["P_std","writeUInt16LE",2]),c.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),c.prototype.fieldSpec.push(["cn0","writeUInt8",1]),c.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),c.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),c.prototype.fieldSpec.push(["doppler","writeInt32LE",4]),c.prototype.fieldSpec.push(["doppler_std","writeUInt16LE",2]),c.prototype.fieldSpec.push(["uptime","writeUInt32LE",4]),c.prototype.fieldSpec.push(["clock_offset","writeInt16LE",2]),c.prototype.fieldSpec.push(["clock_drift","writeInt16LE",2]),c.prototype.fieldSpec.push(["corr_spacing","writeUInt16LE",2]),c.prototype.fieldSpec.push(["acceleration","writeInt8",1]),c.prototype.fieldSpec.push(["sync_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["tow_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["track_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["nav_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["pset_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["misc_flags","writeUInt8",1]);var u=function(e,t){return p.call(this,e),this.messageType="MSG_TRACKING_STATE_DETAILED_DEP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="MSG_TRACKING_STATE_DETAILED_DEP",u.prototype.msg_type=17,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint64("recv_time").nest("tot",{type:l.prototype.parser}).uint32("P").uint16("P_std").nest("L",{type:i.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:n.prototype.parser}).int32("doppler").uint16("doppler_std").uint32("uptime").int16("clock_offset").int16("clock_drift").uint16("corr_spacing").int8("acceleration").uint8("sync_flags").uint8("tow_flags").uint8("track_flags").uint8("nav_flags").uint8("pset_flags").uint8("misc_flags"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["recv_time","writeUInt64LE",8]),u.prototype.fieldSpec.push(["tot",l.prototype.fieldSpec]),u.prototype.fieldSpec.push(["P","writeUInt32LE",4]),u.prototype.fieldSpec.push(["P_std","writeUInt16LE",2]),u.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),u.prototype.fieldSpec.push(["cn0","writeUInt8",1]),u.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),u.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),u.prototype.fieldSpec.push(["doppler","writeInt32LE",4]),u.prototype.fieldSpec.push(["doppler_std","writeUInt16LE",2]),u.prototype.fieldSpec.push(["uptime","writeUInt32LE",4]),u.prototype.fieldSpec.push(["clock_offset","writeInt16LE",2]),u.prototype.fieldSpec.push(["clock_drift","writeInt16LE",2]),u.prototype.fieldSpec.push(["corr_spacing","writeUInt16LE",2]),u.prototype.fieldSpec.push(["acceleration","writeInt8",1]),u.prototype.fieldSpec.push(["sync_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["tow_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["track_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["nav_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["pset_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["misc_flags","writeUInt8",1]);var y=function(e,t){return p.call(this,e),this.messageType="TrackingChannelState",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="TrackingChannelState",y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).uint8("fcn").uint8("cn0"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),y.prototype.fieldSpec.push(["fcn","writeUInt8",1]),y.prototype.fieldSpec.push(["cn0","writeUInt8",1]);var h=function(e,t){return p.call(this,e),this.messageType="MSG_TRACKING_STATE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_TRACKING_STATE",h.prototype.msg_type=65,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").array("states",{type:y.prototype.parser,readUntil:"eof"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["states","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);var f=function(e,t){return p.call(this,e),this.messageType="MeasurementState",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="MeasurementState",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").nest("mesid",{type:s.prototype.parser}).uint8("cn0"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["mesid",s.prototype.fieldSpec]),f.prototype.fieldSpec.push(["cn0","writeUInt8",1]);var d=function(e,t){return p.call(this,e),this.messageType="MSG_MEASUREMENT_STATE",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(p.prototype)).messageType="MSG_MEASUREMENT_STATE",d.prototype.msg_type=97,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").array("states",{type:f.prototype.parser,readUntil:"eof"}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["states","array",f.prototype.fieldSpec,function(){return this.fields.array.length},null]);var _=function(e,t){return p.call(this,e),this.messageType="TrackingChannelCorrelation",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(p.prototype)).messageType="TrackingChannelCorrelation",_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").int16("I").int16("Q"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["I","writeInt16LE",2]),_.prototype.fieldSpec.push(["Q","writeInt16LE",2]);var S=function(e,t){return p.call(this,e),this.messageType="MSG_TRACKING_IQ",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(p.prototype)).messageType="MSG_TRACKING_IQ",S.prototype.msg_type=45,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").uint8("channel").nest("sid",{type:s.prototype.parser}).array("corrs",{length:3,type:_.prototype.parser}),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["channel","writeUInt8",1]),S.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),S.prototype.fieldSpec.push(["corrs","array",_.prototype.fieldSpec,function(){return this.fields.array.length},3]);var g=function(e,t){return p.call(this,e),this.messageType="TrackingChannelCorrelationDep",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(p.prototype)).messageType="TrackingChannelCorrelationDep",g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").int32("I").int32("Q"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["I","writeInt32LE",4]),g.prototype.fieldSpec.push(["Q","writeInt32LE",4]);var w=function(e,t){return p.call(this,e),this.messageType="MSG_TRACKING_IQ_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(p.prototype)).messageType="MSG_TRACKING_IQ_DEP_B",w.prototype.msg_type=44,w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").uint8("channel").nest("sid",{type:s.prototype.parser}).array("corrs",{length:3,type:g.prototype.parser}),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["channel","writeUInt8",1]),w.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),w.prototype.fieldSpec.push(["corrs","array",g.prototype.fieldSpec,function(){return this.fields.array.length},3]);var E=function(e,t){return p.call(this,e),this.messageType="MSG_TRACKING_IQ_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(p.prototype)).messageType="MSG_TRACKING_IQ_DEP_A",E.prototype.msg_type=28,E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").uint8("channel").nest("sid",{type:n.prototype.parser}).array("corrs",{length:3,type:g.prototype.parser}),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["channel","writeUInt8",1]),E.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),E.prototype.fieldSpec.push(["corrs","array",g.prototype.fieldSpec,function(){return this.fields.array.length},3]);var m=function(e,t){return p.call(this,e),this.messageType="TrackingChannelStateDepA",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(p.prototype)).messageType="TrackingChannelStateDepA",m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").uint8("state").uint8("prn").floatle("cn0"),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["state","writeUInt8",1]),m.prototype.fieldSpec.push(["prn","writeUInt8",1]),m.prototype.fieldSpec.push(["cn0","writeFloatLE",4]);var b=function(e,t){return p.call(this,e),this.messageType="MSG_TRACKING_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(p.prototype)).messageType="MSG_TRACKING_STATE_DEP_A",b.prototype.msg_type=22,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").array("states",{type:m.prototype.parser,readUntil:"eof"}),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["states","array",m.prototype.fieldSpec,function(){return this.fields.array.length},null]);var v=function(e,t){return p.call(this,e),this.messageType="TrackingChannelStateDepB",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(p.prototype)).messageType="TrackingChannelStateDepB",v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").uint8("state").nest("sid",{type:n.prototype.parser}).floatle("cn0"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["state","writeUInt8",1]),v.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),v.prototype.fieldSpec.push(["cn0","writeFloatLE",4]);var L=function(e,t){return p.call(this,e),this.messageType="MSG_TRACKING_STATE_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(p.prototype)).messageType="MSG_TRACKING_STATE_DEP_B",L.prototype.msg_type=19,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").array("states",{type:v.prototype.parser,readUntil:"eof"}),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["states","array",v.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={33:c,MsgTrackingStateDetailedDepA:c,17:u,MsgTrackingStateDetailedDep:u,TrackingChannelState:y,65:h,MsgTrackingState:h,MeasurementState:f,97:d,MsgMeasurementState:d,TrackingChannelCorrelation:_,45:S,MsgTrackingIq:S,TrackingChannelCorrelationDep:g,44:w,MsgTrackingIqDepB:w,28:E,MsgTrackingIqDepA:E,TrackingChannelStateDepA:m,22:b,MsgTrackingStateDepA:b,TrackingChannelStateDepB:v,19:L,MsgTrackingStateDepB:L}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_USER_DATA",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_USER_DATA",i.prototype.msg_type=2048,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").array("contents",{type:"uint8",readUntil:"eof"}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["contents","array","writeUInt8",function(){return 1},null]),e.exports={2048:i,MsgUserData:i}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_ODOMETRY",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_ODOMETRY",i.prototype.msg_type=2307,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("tow").int32("velocity").uint8("flags"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["velocity","writeInt32LE",4]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_WHEELTICK",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_WHEELTICK",s.prototype.msg_type=2308,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint64("time").uint8("flags").uint8("source").int32("ticks"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["time","writeUInt64LE",8]),s.prototype.fieldSpec.push(["flags","writeUInt8",1]),s.prototype.fieldSpec.push(["source","writeUInt8",1]),s.prototype.fieldSpec.push(["ticks","writeInt32LE",4]),e.exports={2307:i,MsgOdometry:i,2308:s,MsgWheeltick:s}}]); \ No newline at end of file +function p(e,t){if(e===t)return 0;for(var r=e.length,p=t.length,o=0,i=Math.min(r,p);o=0;l--)if(c[l]!==u[l])return!1;for(l=c.length-1;l>=0;l--)if(a=c[l],!g(e[a],t[a],r,p))return!1;return!0}(e,t,r,s))}return r?e===t:e==t}function w(e){return"[object Arguments]"==Object.prototype.toString.call(e)}function E(e,t){if(!e||!t)return!1;if("[object RegExp]"==Object.prototype.toString.call(t))return t.test(e);try{if(e instanceof t)return!0}catch(e){}return!Error.isPrototypeOf(t)&&!0===t.call({},e)}function m(e,t,r,p){var o;if("function"!=typeof t)throw new TypeError('"block" argument must be a function');"string"==typeof r&&(p=r,r=null),o=function(e){var t;try{e()}catch(e){t=e}return t}(t),p=(r&&r.name?" ("+r.name+").":".")+(p?" "+p:"."),e&&!o&&_(o,r,"Missing expected exception"+p);var s="string"==typeof p,n=!e&&o&&!r;if((!e&&i.isError(o)&&s&&E(o,r)||n)&&_(o,r,"Got unwanted exception"+p),e&&o&&r&&!E(o,r)||!e&&o)throw o}u.AssertionError=function(e){this.name="AssertionError",this.actual=e.actual,this.expected=e.expected,this.operator=e.operator,e.message?(this.message=e.message,this.generatedMessage=!1):(this.message=function(e){return f(d(e.actual),128)+" "+e.operator+" "+f(d(e.expected),128)}(this),this.generatedMessage=!0);var t=e.stackStartFunction||_;if(Error.captureStackTrace)Error.captureStackTrace(this,t);else{var r=new Error;if(r.stack){var p=r.stack,o=h(t),i=p.indexOf("\n"+o);if(i>=0){var s=p.indexOf("\n",i+1);p=p.substring(s+1)}this.stack=p}}},i.inherits(u.AssertionError,Error),u.fail=_,u.ok=S,u.equal=function(e,t,r){e!=t&&_(e,t,r,"==",u.equal)},u.notEqual=function(e,t,r){e==t&&_(e,t,r,"!=",u.notEqual)},u.deepEqual=function(e,t,r){g(e,t,!1)||_(e,t,r,"deepEqual",u.deepEqual)},u.deepStrictEqual=function(e,t,r){g(e,t,!0)||_(e,t,r,"deepStrictEqual",u.deepStrictEqual)},u.notDeepEqual=function(e,t,r){g(e,t,!1)&&_(e,t,r,"notDeepEqual",u.notDeepEqual)},u.notDeepStrictEqual=function e(t,r,p){g(t,r,!0)&&_(t,r,p,"notDeepStrictEqual",e)},u.strictEqual=function(e,t,r){e!==t&&_(e,t,r,"===",u.strictEqual)},u.notStrictEqual=function(e,t,r){e===t&&_(e,t,r,"!==",u.notStrictEqual)},u.throws=function(e,t,r){m(!0,e,t,r)},u.doesNotThrow=function(e,t,r){m(!1,e,t,r)},u.ifError=function(e){if(e)throw e};var b=Object.keys||function(e){var t=[];for(var r in e)s.call(e,r)&&t.push(r);return t}}).call(this,r(5))},function(e,t,r){var p;!function(r){o(Math.pow(36,5)),o(Math.pow(16,7)),o(Math.pow(10,9)),o(Math.pow(2,30)),o(36),o(16),o(10),o(2);function o(e,t){return this instanceof o?(this._low=0,this._high=0,this.remainder=null,void 0===t?s.call(this,e):"string"==typeof e?n.call(this,e,t):void i.call(this,e,t)):new o(e,t)}function i(e,t){return this._low=0|e,this._high=0|t,this}function s(e){return this._low=65535&e,this._high=e>>>16,this}function n(e,t){var r=parseInt(e,t||10);return this._low=65535&r,this._high=r>>>16,this}o.prototype.fromBits=i,o.prototype.fromNumber=s,o.prototype.fromString=n,o.prototype.toNumber=function(){return 65536*this._high+this._low},o.prototype.toString=function(e){return this.toNumber().toString(e||10)},o.prototype.add=function(e){var t=this._low+e._low,r=t>>>16;return r+=this._high+e._high,this._low=65535&t,this._high=65535&r,this},o.prototype.subtract=function(e){return this.add(e.clone().negate())},o.prototype.multiply=function(e){var t,r,p=this._high,o=this._low,i=e._high,s=e._low;return t=(r=o*s)>>>16,t+=p*s,t&=65535,t+=o*i,this._low=65535&r,this._high=65535&t,this},o.prototype.div=function(e){if(0==e._low&&0==e._high)throw Error("division by zero");if(0==e._high&&1==e._low)return this.remainder=new o(0),this;if(e.gt(this))return this.remainder=this.clone(),this._low=0,this._high=0,this;if(this.eq(e))return this.remainder=new o(0),this._low=1,this._high=0,this;for(var t=e.clone(),r=-1;!this.lt(t);)t.shiftLeft(1,!0),r++;for(this.remainder=this.clone(),this._low=0,this._high=0;r>=0;r--)t.shiftRight(1),this.remainder.lt(t)||(this.remainder.subtract(t),r>=16?this._high|=1<>>16)&65535,this},o.prototype.equals=o.prototype.eq=function(e){return this._low==e._low&&this._high==e._high},o.prototype.greaterThan=o.prototype.gt=function(e){return this._high>e._high||!(this._highe._low},o.prototype.lessThan=o.prototype.lt=function(e){return this._highe._high)&&this._low16?(this._low=this._high>>e-16,this._high=0):16==e?(this._low=this._high,this._high=0):(this._low=this._low>>e|this._high<<16-e&65535,this._high>>=e),this},o.prototype.shiftLeft=o.prototype.shiftl=function(e,t){return e>16?(this._high=this._low<>16-e,this._low=this._low<>>32-e,this._low=65535&t,this._high=t>>>16,this},o.prototype.rotateRight=o.prototype.rotr=function(e){var t=this._high<<16|this._low;return t=t>>>e|t<<32-e,this._low=65535&t,this._high=t>>>16,this},o.prototype.clone=function(){return new o(this._low,this._high)},void 0===(p=function(){return o}.apply(t,[]))||(e.exports=p)}()},function(e,t,r){var p;!function(r){var o={16:s(Math.pow(16,5)),10:s(Math.pow(10,5)),2:s(Math.pow(2,5))},i={16:s(16),10:s(10),2:s(2)};function s(e,t,r,p){return this instanceof s?(this.remainder=null,"string"==typeof e?l.call(this,e,t):void 0===t?a.call(this,e):void n.apply(this,arguments)):new s(e,t,r,p)}function n(e,t,r,p){return void 0===r?(this._a00=65535&e,this._a16=e>>>16,this._a32=65535&t,this._a48=t>>>16,this):(this._a00=0|e,this._a16=0|t,this._a32=0|r,this._a48=0|p,this)}function a(e){return this._a00=65535&e,this._a16=e>>>16,this._a32=0,this._a48=0,this}function l(e,t){t=t||10,this._a00=0,this._a16=0,this._a32=0,this._a48=0;for(var r=o[t]||new s(Math.pow(t,5)),p=0,i=e.length;p=0&&(r.div(t),p[o]=r.remainder.toNumber().toString(e),r.gt(t));o--);return p[o-1]=r.toNumber().toString(e),p.join("")},s.prototype.add=function(e){var t=this._a00+e._a00,r=t>>>16,p=(r+=this._a16+e._a16)>>>16,o=(p+=this._a32+e._a32)>>>16;return o+=this._a48+e._a48,this._a00=65535&t,this._a16=65535&r,this._a32=65535&p,this._a48=65535&o,this},s.prototype.subtract=function(e){return this.add(e.clone().negate())},s.prototype.multiply=function(e){var t=this._a00,r=this._a16,p=this._a32,o=this._a48,i=e._a00,s=e._a16,n=e._a32,a=t*i,l=a>>>16,c=(l+=t*s)>>>16;l&=65535,c+=(l+=r*i)>>>16;var u=(c+=t*n)>>>16;return c&=65535,u+=(c+=r*s)>>>16,c&=65535,u+=(c+=p*i)>>>16,u+=t*e._a48,u&=65535,u+=r*n,u&=65535,u+=p*s,u&=65535,u+=o*i,this._a00=65535&a,this._a16=65535&l,this._a32=65535&c,this._a48=65535&u,this},s.prototype.div=function(e){if(0==e._a16&&0==e._a32&&0==e._a48){if(0==e._a00)throw Error("division by zero");if(1==e._a00)return this.remainder=new s(0),this}if(e.gt(this))return this.remainder=this.clone(),this._a00=0,this._a16=0,this._a32=0,this._a48=0,this;if(this.eq(e))return this.remainder=new s(0),this._a00=1,this._a16=0,this._a32=0,this._a48=0,this;for(var t=e.clone(),r=-1;!this.lt(t);)t.shiftLeft(1,!0),r++;for(this.remainder=this.clone(),this._a00=0,this._a16=0,this._a32=0,this._a48=0;r>=0;r--)t.shiftRight(1),this.remainder.lt(t)||(this.remainder.subtract(t),r>=48?this._a48|=1<=32?this._a32|=1<=16?this._a16|=1<>>16),this._a16=65535&e,e=(65535&~this._a32)+(e>>>16),this._a32=65535&e,this._a48=~this._a48+(e>>>16)&65535,this},s.prototype.equals=s.prototype.eq=function(e){return this._a48==e._a48&&this._a00==e._a00&&this._a32==e._a32&&this._a16==e._a16},s.prototype.greaterThan=s.prototype.gt=function(e){return this._a48>e._a48||!(this._a48e._a32||!(this._a32e._a16||!(this._a16e._a00))},s.prototype.lessThan=s.prototype.lt=function(e){return this._a48e._a48)&&(this._a32e._a32)&&(this._a16e._a16)&&this._a00=48?(this._a00=this._a48>>e-48,this._a16=0,this._a32=0,this._a48=0):e>=32?(e-=32,this._a00=65535&(this._a32>>e|this._a48<<16-e),this._a16=this._a48>>e&65535,this._a32=0,this._a48=0):e>=16?(e-=16,this._a00=65535&(this._a16>>e|this._a32<<16-e),this._a16=65535&(this._a32>>e|this._a48<<16-e),this._a32=this._a48>>e&65535,this._a48=0):(this._a00=65535&(this._a00>>e|this._a16<<16-e),this._a16=65535&(this._a16>>e|this._a32<<16-e),this._a32=65535&(this._a32>>e|this._a48<<16-e),this._a48=this._a48>>e&65535),this},s.prototype.shiftLeft=s.prototype.shiftl=function(e,t){return(e%=64)>=48?(this._a48=this._a00<=32?(e-=32,this._a48=this._a16<>16-e,this._a32=this._a00<=16?(e-=16,this._a48=this._a32<>16-e,this._a32=65535&(this._a16<>16-e),this._a16=this._a00<>16-e,this._a32=65535&(this._a32<>16-e),this._a16=65535&(this._a16<>16-e),this._a00=this._a00<=32){var t=this._a00;if(this._a00=this._a32,this._a32=t,t=this._a48,this._a48=this._a16,this._a16=t,32==e)return this;e-=32}var r=this._a48<<16|this._a32,p=this._a16<<16|this._a00,o=r<>>32-e,i=p<>>32-e;return this._a00=65535&i,this._a16=i>>>16,this._a32=65535&o,this._a48=o>>>16,this},s.prototype.rotateRight=s.prototype.rotr=function(e){if(0==(e%=64))return this;if(e>=32){var t=this._a00;if(this._a00=this._a32,this._a32=t,t=this._a48,this._a48=this._a16,this._a16=t,32==e)return this;e-=32}var r=this._a48<<16|this._a32,p=this._a16<<16|this._a00,o=r>>>e|p<<32-e,i=p>>>e|r<<32-e;return this._a00=65535&i,this._a16=i>>>16,this._a32=65535&o,this._a48=o>>>16,this},s.prototype.clone=function(){return new s(this._a00,this._a16,this._a32,this._a48)},void 0===(p=function(){return s}.apply(t,[]))||(e.exports=p)}()},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,r(0).CarrierPhase,r(0).GnssSignal),s=r(0).GnssSignalDep,n=(r(0).GPSTime,r(0).GPSTimeDep,r(0).GPSTimeSec,r(0).SvId,function(e,t){return p.call(this,e),this.messageType="MSG_ACQ_RESULT",this.fields=t||this.parser.parse(e.payload),this});(n.prototype=Object.create(p.prototype)).messageType="MSG_ACQ_RESULT",n.prototype.msg_type=47,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").floatle("cn0").floatle("cp").floatle("cf").nest("sid",{type:i.prototype.parser}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["cn0","writeFloatLE",4]),n.prototype.fieldSpec.push(["cp","writeFloatLE",4]),n.prototype.fieldSpec.push(["cf","writeFloatLE",4]),n.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]);var a=function(e,t){return p.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="MSG_ACQ_RESULT_DEP_C",a.prototype.msg_type=31,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").floatle("cn0").floatle("cp").floatle("cf").nest("sid",{type:s.prototype.parser}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["cn0","writeFloatLE",4]),a.prototype.fieldSpec.push(["cp","writeFloatLE",4]),a.prototype.fieldSpec.push(["cf","writeFloatLE",4]),a.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);var l=function(e,t){return p.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="MSG_ACQ_RESULT_DEP_B",l.prototype.msg_type=20,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").floatle("snr").floatle("cp").floatle("cf").nest("sid",{type:s.prototype.parser}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["snr","writeFloatLE",4]),l.prototype.fieldSpec.push(["cp","writeFloatLE",4]),l.prototype.fieldSpec.push(["cf","writeFloatLE",4]),l.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);var c=function(e,t){return p.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="MSG_ACQ_RESULT_DEP_A",c.prototype.msg_type=21,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").floatle("snr").floatle("cp").floatle("cf").uint8("prn"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["snr","writeFloatLE",4]),c.prototype.fieldSpec.push(["cp","writeFloatLE",4]),c.prototype.fieldSpec.push(["cf","writeFloatLE",4]),c.prototype.fieldSpec.push(["prn","writeUInt8",1]);var u=function(e,t){return p.call(this,e),this.messageType="AcqSvProfile",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="AcqSvProfile",u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint8("job_type").uint8("status").uint16("cn0").uint8("int_time").nest("sid",{type:i.prototype.parser}).uint16("bin_width").uint32("timestamp").uint32("time_spent").int32("cf_min").int32("cf_max").int32("cf").uint32("cp"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["job_type","writeUInt8",1]),u.prototype.fieldSpec.push(["status","writeUInt8",1]),u.prototype.fieldSpec.push(["cn0","writeUInt16LE",2]),u.prototype.fieldSpec.push(["int_time","writeUInt8",1]),u.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),u.prototype.fieldSpec.push(["bin_width","writeUInt16LE",2]),u.prototype.fieldSpec.push(["timestamp","writeUInt32LE",4]),u.prototype.fieldSpec.push(["time_spent","writeUInt32LE",4]),u.prototype.fieldSpec.push(["cf_min","writeInt32LE",4]),u.prototype.fieldSpec.push(["cf_max","writeInt32LE",4]),u.prototype.fieldSpec.push(["cf","writeInt32LE",4]),u.prototype.fieldSpec.push(["cp","writeUInt32LE",4]);var y=function(e,t){return p.call(this,e),this.messageType="AcqSvProfileDep",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="AcqSvProfileDep",y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint8("job_type").uint8("status").uint16("cn0").uint8("int_time").nest("sid",{type:s.prototype.parser}).uint16("bin_width").uint32("timestamp").uint32("time_spent").int32("cf_min").int32("cf_max").int32("cf").uint32("cp"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["job_type","writeUInt8",1]),y.prototype.fieldSpec.push(["status","writeUInt8",1]),y.prototype.fieldSpec.push(["cn0","writeUInt16LE",2]),y.prototype.fieldSpec.push(["int_time","writeUInt8",1]),y.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),y.prototype.fieldSpec.push(["bin_width","writeUInt16LE",2]),y.prototype.fieldSpec.push(["timestamp","writeUInt32LE",4]),y.prototype.fieldSpec.push(["time_spent","writeUInt32LE",4]),y.prototype.fieldSpec.push(["cf_min","writeInt32LE",4]),y.prototype.fieldSpec.push(["cf_max","writeInt32LE",4]),y.prototype.fieldSpec.push(["cf","writeInt32LE",4]),y.prototype.fieldSpec.push(["cp","writeUInt32LE",4]);var h=function(e,t){return p.call(this,e),this.messageType="MSG_ACQ_SV_PROFILE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_ACQ_SV_PROFILE",h.prototype.msg_type=46,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").array("acq_sv_profile",{type:u.prototype.parser,readUntil:"eof"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["acq_sv_profile","array",u.prototype.fieldSpec,function(){return this.fields.array.length},null]);var f=function(e,t){return p.call(this,e),this.messageType="MSG_ACQ_SV_PROFILE_DEP",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="MSG_ACQ_SV_PROFILE_DEP",f.prototype.msg_type=30,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").array("acq_sv_profile",{type:y.prototype.parser,readUntil:"eof"}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["acq_sv_profile","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={47:n,MsgAcqResult:n,31:a,MsgAcqResultDepC:a,20:l,MsgAcqResultDepB:l,21:c,MsgAcqResultDepA:c,AcqSvProfile:u,AcqSvProfileDep:y,46:h,MsgAcqSvProfile:h,30:f,MsgAcqSvProfileDep:f}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_REQ",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_BOOTLOADER_HANDSHAKE_REQ",i.prototype.msg_type=179,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little"),i.prototype.fieldSpec=[];var s=function(e,t){return p.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_RESP",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_BOOTLOADER_HANDSHAKE_RESP",s.prototype.msg_type=180,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint32("flags").string("version",{greedy:!0}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["flags","writeUInt32LE",4]),s.prototype.fieldSpec.push(["version","string",null]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_BOOTLOADER_JUMP_TO_APP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_BOOTLOADER_JUMP_TO_APP",n.prototype.msg_type=177,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("jump"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["jump","writeUInt8",1]);var a=function(e,t){return p.call(this,e),this.messageType="MSG_NAP_DEVICE_DNA_REQ",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="MSG_NAP_DEVICE_DNA_REQ",a.prototype.msg_type=222,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little"),a.prototype.fieldSpec=[];var l=function(e,t){return p.call(this,e),this.messageType="MSG_NAP_DEVICE_DNA_RESP",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="MSG_NAP_DEVICE_DNA_RESP",l.prototype.msg_type=221,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").array("dna",{length:8,type:"uint8"}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["dna","array","writeUInt8",function(){return 1},8]);var c=function(e,t){return p.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="MSG_BOOTLOADER_HANDSHAKE_DEP_A",c.prototype.msg_type=176,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").array("handshake",{type:"uint8",readUntil:"eof"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["handshake","array","writeUInt8",function(){return 1},null]),e.exports={179:i,MsgBootloaderHandshakeReq:i,180:s,MsgBootloaderHandshakeResp:s,177:n,MsgBootloaderJumpToApp:n,222:a,MsgNapDeviceDnaReq:a,221:l,MsgNapDeviceDnaResp:l,176:c,MsgBootloaderHandshakeDepA:c}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_EXT_EVENT",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_EXT_EVENT",i.prototype.msg_type=257,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").int32("ns_residual").uint8("flags").uint8("pin"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]),i.prototype.fieldSpec.push(["pin","writeUInt8",1]),e.exports={257:i,MsgExtEvent:i}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_READ_REQ",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_READ_REQ",i.prototype.msg_type=168,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("offset").uint8("chunk_size").string("filename",{greedy:!0}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),i.prototype.fieldSpec.push(["offset","writeUInt32LE",4]),i.prototype.fieldSpec.push(["chunk_size","writeUInt8",1]),i.prototype.fieldSpec.push(["filename","string",null]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_READ_RESP",s.prototype.msg_type=163,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint32("sequence").array("contents",{type:"uint8",readUntil:"eof"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),s.prototype.fieldSpec.push(["contents","array","writeUInt8",function(){return 1},null]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_READ_DIR_REQ",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_READ_DIR_REQ",n.prototype.msg_type=169,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("offset").string("dirname",{greedy:!0}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),n.prototype.fieldSpec.push(["offset","writeUInt32LE",4]),n.prototype.fieldSpec.push(["dirname","string",null]);var a=function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_READ_DIR_RESP",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_READ_DIR_RESP",a.prototype.msg_type=170,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint32("sequence").array("contents",{type:"uint8",readUntil:"eof"}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),a.prototype.fieldSpec.push(["contents","array","writeUInt8",function(){return 1},null]);var l=function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_REMOVE",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_REMOVE",l.prototype.msg_type=172,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").string("filename",{greedy:!0}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["filename","string",null]);var c=function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_WRITE_REQ",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_WRITE_REQ",c.prototype.msg_type=173,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("offset").string("filename",{greedy:!0}).array("data",{type:"uint8",readUntil:"eof"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),c.prototype.fieldSpec.push(["offset","writeUInt32LE",4]),c.prototype.fieldSpec.push(["filename","string",null]),c.prototype.fieldSpec.push(["data","array","writeUInt8",function(){return 1},null]);var u=function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_WRITE_RESP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_WRITE_RESP",u.prototype.msg_type=171,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("sequence"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]);var y=function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_CONFIG_REQ",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_CONFIG_REQ",y.prototype.msg_type=4097,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint32("sequence"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]);var h=function(e,t){return p.call(this,e),this.messageType="MSG_FILEIO_CONFIG_RESP",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_FILEIO_CONFIG_RESP",h.prototype.msg_type=4098,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint32("sequence").uint32("window_size").uint32("batch_size").uint32("fileio_version"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),h.prototype.fieldSpec.push(["window_size","writeUInt32LE",4]),h.prototype.fieldSpec.push(["batch_size","writeUInt32LE",4]),h.prototype.fieldSpec.push(["fileio_version","writeUInt32LE",4]),e.exports={168:i,MsgFileioReadReq:i,163:s,MsgFileioReadResp:s,169:n,MsgFileioReadDirReq:n,170:a,MsgFileioReadDirResp:a,172:l,MsgFileioRemove:l,173:c,MsgFileioWriteReq:c,171:u,MsgFileioWriteResp:u,4097:y,MsgFileioConfigReq:y,4098:h,MsgFileioConfigResp:h}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_FLASH_PROGRAM",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_FLASH_PROGRAM",i.prototype.msg_type=230,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("target").array("addr_start",{length:3,type:"uint8"}).uint8("addr_len").array("data",{type:"uint8",length:"addr_len"}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["target","writeUInt8",1]),i.prototype.fieldSpec.push(["addr_start","array","writeUInt8",function(){return 1},3]),i.prototype.fieldSpec.push(["addr_len","writeUInt8",1]),i.prototype.fieldSpec.push(["data","array","writeUInt8",function(){return 1},"addr_len"]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_FLASH_DONE",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_FLASH_DONE",s.prototype.msg_type=224,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("response"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["response","writeUInt8",1]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_FLASH_READ_REQ",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_FLASH_READ_REQ",n.prototype.msg_type=231,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("target").array("addr_start",{length:3,type:"uint8"}).uint8("addr_len"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["target","writeUInt8",1]),n.prototype.fieldSpec.push(["addr_start","array","writeUInt8",function(){return 1},3]),n.prototype.fieldSpec.push(["addr_len","writeUInt8",1]);var a=function(e,t){return p.call(this,e),this.messageType="MSG_FLASH_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="MSG_FLASH_READ_RESP",a.prototype.msg_type=225,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("target").array("addr_start",{length:3,type:"uint8"}).uint8("addr_len"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["target","writeUInt8",1]),a.prototype.fieldSpec.push(["addr_start","array","writeUInt8",function(){return 1},3]),a.prototype.fieldSpec.push(["addr_len","writeUInt8",1]);var l=function(e,t){return p.call(this,e),this.messageType="MSG_FLASH_ERASE",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="MSG_FLASH_ERASE",l.prototype.msg_type=226,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("target").uint32("sector_num"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["target","writeUInt8",1]),l.prototype.fieldSpec.push(["sector_num","writeUInt32LE",4]);var c=function(e,t){return p.call(this,e),this.messageType="MSG_STM_FLASH_LOCK_SECTOR",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="MSG_STM_FLASH_LOCK_SECTOR",c.prototype.msg_type=227,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("sector"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["sector","writeUInt32LE",4]);var u=function(e,t){return p.call(this,e),this.messageType="MSG_STM_FLASH_UNLOCK_SECTOR",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="MSG_STM_FLASH_UNLOCK_SECTOR",u.prototype.msg_type=228,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("sector"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["sector","writeUInt32LE",4]);var y=function(e,t){return p.call(this,e),this.messageType="MSG_STM_UNIQUE_ID_REQ",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="MSG_STM_UNIQUE_ID_REQ",y.prototype.msg_type=232,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little"),y.prototype.fieldSpec=[];var h=function(e,t){return p.call(this,e),this.messageType="MSG_STM_UNIQUE_ID_RESP",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_STM_UNIQUE_ID_RESP",h.prototype.msg_type=229,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").array("stm_id",{length:12,type:"uint8"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["stm_id","array","writeUInt8",function(){return 1},12]);var f=function(e,t){return p.call(this,e),this.messageType="MSG_M25_FLASH_WRITE_STATUS",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="MSG_M25_FLASH_WRITE_STATUS",f.prototype.msg_type=243,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").array("status",{length:1,type:"uint8"}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["status","array","writeUInt8",function(){return 1},1]),e.exports={230:i,MsgFlashProgram:i,224:s,MsgFlashDone:s,231:n,MsgFlashReadReq:n,225:a,MsgFlashReadResp:a,226:l,MsgFlashErase:l,227:c,MsgStmFlashLockSector:c,228:u,MsgStmFlashUnlockSector:u,232:y,MsgStmUniqueIdReq:y,229:h,MsgStmUniqueIdResp:h,243:f,MsgM25FlashWriteStatus:f}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_IMU_RAW",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_IMU_RAW",i.prototype.msg_type=2304,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("tow").uint8("tow_f").int16("acc_x").int16("acc_y").int16("acc_z").int16("gyr_x").int16("gyr_y").int16("gyr_z"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["tow_f","writeUInt8",1]),i.prototype.fieldSpec.push(["acc_x","writeInt16LE",2]),i.prototype.fieldSpec.push(["acc_y","writeInt16LE",2]),i.prototype.fieldSpec.push(["acc_z","writeInt16LE",2]),i.prototype.fieldSpec.push(["gyr_x","writeInt16LE",2]),i.prototype.fieldSpec.push(["gyr_y","writeInt16LE",2]),i.prototype.fieldSpec.push(["gyr_z","writeInt16LE",2]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_IMU_AUX",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_IMU_AUX",s.prototype.msg_type=2305,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("imu_type").int16("temp").uint8("imu_conf"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["imu_type","writeUInt8",1]),s.prototype.fieldSpec.push(["temp","writeInt16LE",2]),s.prototype.fieldSpec.push(["imu_conf","writeUInt8",1]),e.exports={2304:i,MsgImuRaw:i,2305:s,MsgImuAux:s}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,r(0).CarrierPhase,r(0).GnssSignal,r(0).GnssSignalDep,r(0).GPSTime,r(0).GPSTimeDep,r(0).GPSTimeSec,r(0).SvId,function(e,t){return p.call(this,e),this.messageType="MSG_SSR_FLAG_HIGH_LEVEL",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_SSR_FLAG_HIGH_LEVEL",i.prototype.msg_type=3001,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").array("stub",{type:"uint8",readUntil:"eof"}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["stub","array","writeUInt8",function(){return 1},null]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_FLAG_SATELLITES",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_SSR_FLAG_SATELLITES",s.prototype.msg_type=3005,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").array("stub",{type:"uint8",readUntil:"eof"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["stub","array","writeUInt8",function(){return 1},null]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_FLAG_TROPO_GRID_POINTS",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_SSR_FLAG_TROPO_GRID_POINTS",n.prototype.msg_type=3011,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").array("stub",{type:"uint8",readUntil:"eof"}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["stub","array","writeUInt8",function(){return 1},null]);var a=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_FLAG_IONO_GRID_POINTS",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="MSG_SSR_FLAG_IONO_GRID_POINTS",a.prototype.msg_type=3015,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").array("stub",{type:"uint8",readUntil:"eof"}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["stub","array","writeUInt8",function(){return 1},null]);var l=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_FLAG_IONO_TILE_SAT_LOS",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="MSG_SSR_FLAG_IONO_TILE_SAT_LOS",l.prototype.msg_type=3021,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").array("stub",{type:"uint8",readUntil:"eof"}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["stub","array","writeUInt8",function(){return 1},null]);var c=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS",c.prototype.msg_type=3025,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").array("stub",{type:"uint8",readUntil:"eof"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["stub","array","writeUInt8",function(){return 1},null]),e.exports={3001:i,MsgSsrFlagHighLevel:i,3005:s,MsgSsrFlagSatellites:s,3011:n,MsgSsrFlagTropoGridPoints:n,3015:a,MsgSsrFlagIonoGridPoints:a,3021:l,MsgSsrFlagIonoTileSatLos:l,3025:c,MsgSsrFlagIonoGridPointSatLos:c}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_CPU_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_CPU_STATE_DEP_A",i.prototype.msg_type=32512,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pcpu").string("tname",{length:15}).string("cmdline",{greedy:!0}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["index","writeUInt8",1]),i.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),i.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),i.prototype.fieldSpec.push(["tname","string",15]),i.prototype.fieldSpec.push(["cmdline","string",null]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_MEM_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_MEM_STATE_DEP_A",s.prototype.msg_type=32513,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pmem").string("tname",{length:15}).string("cmdline",{greedy:!0}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["index","writeUInt8",1]),s.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),s.prototype.fieldSpec.push(["pmem","writeUInt8",1]),s.prototype.fieldSpec.push(["tname","string",15]),s.prototype.fieldSpec.push(["cmdline","string",null]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_SYS_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_SYS_STATE_DEP_A",n.prototype.msg_type=32514,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint16("mem_total").uint8("pcpu").uint8("pmem").uint16("procs_starting").uint16("procs_stopping").uint16("pid_count"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["mem_total","writeUInt16LE",2]),n.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),n.prototype.fieldSpec.push(["pmem","writeUInt8",1]),n.prototype.fieldSpec.push(["procs_starting","writeUInt16LE",2]),n.prototype.fieldSpec.push(["procs_stopping","writeUInt16LE",2]),n.prototype.fieldSpec.push(["pid_count","writeUInt16LE",2]);var a=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_PROCESS_SOCKET_COUNTS",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_PROCESS_SOCKET_COUNTS",a.prototype.msg_type=32515,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint16("socket_count").uint16("socket_types").uint16("socket_states").string("cmdline",{greedy:!0}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["index","writeUInt8",1]),a.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),a.prototype.fieldSpec.push(["socket_count","writeUInt16LE",2]),a.prototype.fieldSpec.push(["socket_types","writeUInt16LE",2]),a.prototype.fieldSpec.push(["socket_states","writeUInt16LE",2]),a.prototype.fieldSpec.push(["cmdline","string",null]);var l=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_PROCESS_SOCKET_QUEUES",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_PROCESS_SOCKET_QUEUES",l.prototype.msg_type=32516,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint16("recv_queued").uint16("send_queued").uint16("socket_types").uint16("socket_states").string("address_of_largest",{length:64}).string("cmdline",{greedy:!0}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["index","writeUInt8",1]),l.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),l.prototype.fieldSpec.push(["recv_queued","writeUInt16LE",2]),l.prototype.fieldSpec.push(["send_queued","writeUInt16LE",2]),l.prototype.fieldSpec.push(["socket_types","writeUInt16LE",2]),l.prototype.fieldSpec.push(["socket_states","writeUInt16LE",2]),l.prototype.fieldSpec.push(["address_of_largest","string",64]),l.prototype.fieldSpec.push(["cmdline","string",null]);var c=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_SOCKET_USAGE",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_SOCKET_USAGE",c.prototype.msg_type=32517,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("avg_queue_depth").uint32("max_queue_depth").array("socket_state_counts",{length:16,type:"uint16le"}).array("socket_type_counts",{length:16,type:"uint16le"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["avg_queue_depth","writeUInt32LE",4]),c.prototype.fieldSpec.push(["max_queue_depth","writeUInt32LE",4]),c.prototype.fieldSpec.push(["socket_state_counts","array","writeUInt16LE",function(){return 2},16]),c.prototype.fieldSpec.push(["socket_type_counts","array","writeUInt16LE",function(){return 2},16]);var u=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_PROCESS_FD_COUNT",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_PROCESS_FD_COUNT",u.prototype.msg_type=32518,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint16("fd_count").string("cmdline",{greedy:!0}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["index","writeUInt8",1]),u.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),u.prototype.fieldSpec.push(["fd_count","writeUInt16LE",2]),u.prototype.fieldSpec.push(["cmdline","string",null]);var y=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_PROCESS_FD_SUMMARY",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_PROCESS_FD_SUMMARY",y.prototype.msg_type=32519,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint32("sys_fd_count").string("most_opened",{greedy:!0}),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["sys_fd_count","writeUInt32LE",4]),y.prototype.fieldSpec.push(["most_opened","string",null]);var h=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_CPU_STATE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_CPU_STATE",h.prototype.msg_type=32520,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pcpu").uint32("time").uint8("flags").string("tname",{length:15}).string("cmdline",{greedy:!0}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["index","writeUInt8",1]),h.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),h.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),h.prototype.fieldSpec.push(["time","writeUInt32LE",4]),h.prototype.fieldSpec.push(["flags","writeUInt8",1]),h.prototype.fieldSpec.push(["tname","string",15]),h.prototype.fieldSpec.push(["cmdline","string",null]);var f=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_MEM_STATE",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_MEM_STATE",f.prototype.msg_type=32521,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("index").uint16("pid").uint8("pmem").uint32("time").uint8("flags").string("tname",{length:15}).string("cmdline",{greedy:!0}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["index","writeUInt8",1]),f.prototype.fieldSpec.push(["pid","writeUInt16LE",2]),f.prototype.fieldSpec.push(["pmem","writeUInt8",1]),f.prototype.fieldSpec.push(["time","writeUInt32LE",4]),f.prototype.fieldSpec.push(["flags","writeUInt8",1]),f.prototype.fieldSpec.push(["tname","string",15]),f.prototype.fieldSpec.push(["cmdline","string",null]);var d=function(e,t){return p.call(this,e),this.messageType="MSG_LINUX_SYS_STATE",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(p.prototype)).messageType="MSG_LINUX_SYS_STATE",d.prototype.msg_type=32522,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint16("mem_total").uint8("pcpu").uint8("pmem").uint16("procs_starting").uint16("procs_stopping").uint16("pid_count").uint32("time").uint8("flags"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["mem_total","writeUInt16LE",2]),d.prototype.fieldSpec.push(["pcpu","writeUInt8",1]),d.prototype.fieldSpec.push(["pmem","writeUInt8",1]),d.prototype.fieldSpec.push(["procs_starting","writeUInt16LE",2]),d.prototype.fieldSpec.push(["procs_stopping","writeUInt16LE",2]),d.prototype.fieldSpec.push(["pid_count","writeUInt16LE",2]),d.prototype.fieldSpec.push(["time","writeUInt32LE",4]),d.prototype.fieldSpec.push(["flags","writeUInt8",1]),e.exports={32512:i,MsgLinuxCpuStateDepA:i,32513:s,MsgLinuxMemStateDepA:s,32514:n,MsgLinuxSysStateDepA:n,32515:a,MsgLinuxProcessSocketCounts:a,32516:l,MsgLinuxProcessSocketQueues:l,32517:c,MsgLinuxSocketUsage:c,32518:u,MsgLinuxProcessFdCount:u,32519:y,MsgLinuxProcessFdSummary:y,32520:h,MsgLinuxCpuState:h,32521:f,MsgLinuxMemState:f,32522:d,MsgLinuxSysState:d}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_LOG",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_LOG",i.prototype.msg_type=1025,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("level").string("text",{greedy:!0}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["level","writeUInt8",1]),i.prototype.fieldSpec.push(["text","string",null]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_FWD",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_FWD",s.prototype.msg_type=1026,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("source").uint8("protocol").array("fwd_payload",{type:"uint8",readUntil:"eof"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["source","writeUInt8",1]),s.prototype.fieldSpec.push(["protocol","writeUInt8",1]),s.prototype.fieldSpec.push(["fwd_payload","array","writeUInt8",function(){return 1},null]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_PRINT_DEP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_PRINT_DEP",n.prototype.msg_type=16,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").string("text",{greedy:!0}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["text","string",null]),e.exports={1025:i,MsgLog:i,1026:s,MsgFwd:s,16:n,MsgPrintDep:n}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_MAG_RAW",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_MAG_RAW",i.prototype.msg_type=2306,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("tow").uint8("tow_f").int16("mag_x").int16("mag_y").int16("mag_z"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["tow_f","writeUInt8",1]),i.prototype.fieldSpec.push(["mag_x","writeInt16LE",2]),i.prototype.fieldSpec.push(["mag_y","writeInt16LE",2]),i.prototype.fieldSpec.push(["mag_z","writeInt16LE",2]),e.exports={2306:i,MsgMagRaw:i}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_GPS_TIME",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_GPS_TIME",i.prototype.msg_type=258,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").int32("ns_residual").uint8("flags"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_GPS_TIME_GNSS",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_GPS_TIME_GNSS",s.prototype.msg_type=260,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").int32("ns_residual").uint8("flags"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),s.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),s.prototype.fieldSpec.push(["flags","writeUInt8",1]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_UTC_TIME",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_UTC_TIME",n.prototype.msg_type=259,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("flags").uint32("tow").uint16("year").uint8("month").uint8("day").uint8("hours").uint8("minutes").uint8("seconds").uint32("ns"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["flags","writeUInt8",1]),n.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),n.prototype.fieldSpec.push(["year","writeUInt16LE",2]),n.prototype.fieldSpec.push(["month","writeUInt8",1]),n.prototype.fieldSpec.push(["day","writeUInt8",1]),n.prototype.fieldSpec.push(["hours","writeUInt8",1]),n.prototype.fieldSpec.push(["minutes","writeUInt8",1]),n.prototype.fieldSpec.push(["seconds","writeUInt8",1]),n.prototype.fieldSpec.push(["ns","writeUInt32LE",4]);var a=function(e,t){return p.call(this,e),this.messageType="MSG_UTC_TIME_GNSS",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="MSG_UTC_TIME_GNSS",a.prototype.msg_type=261,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("flags").uint32("tow").uint16("year").uint8("month").uint8("day").uint8("hours").uint8("minutes").uint8("seconds").uint32("ns"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["flags","writeUInt8",1]),a.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),a.prototype.fieldSpec.push(["year","writeUInt16LE",2]),a.prototype.fieldSpec.push(["month","writeUInt8",1]),a.prototype.fieldSpec.push(["day","writeUInt8",1]),a.prototype.fieldSpec.push(["hours","writeUInt8",1]),a.prototype.fieldSpec.push(["minutes","writeUInt8",1]),a.prototype.fieldSpec.push(["seconds","writeUInt8",1]),a.prototype.fieldSpec.push(["ns","writeUInt32LE",4]);var l=function(e,t){return p.call(this,e),this.messageType="MSG_DOPS",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="MSG_DOPS",l.prototype.msg_type=520,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint32("tow").uint16("gdop").uint16("pdop").uint16("tdop").uint16("hdop").uint16("vdop").uint8("flags"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),l.prototype.fieldSpec.push(["gdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["tdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["vdop","writeUInt16LE",2]),l.prototype.fieldSpec.push(["flags","writeUInt8",1]);var c=function(e,t){return p.call(this,e),this.messageType="MSG_POS_ECEF",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="MSG_POS_ECEF",c.prototype.msg_type=521,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").uint16("accuracy").uint8("n_sats").uint8("flags"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),c.prototype.fieldSpec.push(["x","writeDoubleLE",8]),c.prototype.fieldSpec.push(["y","writeDoubleLE",8]),c.prototype.fieldSpec.push(["z","writeDoubleLE",8]),c.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),c.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),c.prototype.fieldSpec.push(["flags","writeUInt8",1]);var u=function(e,t){return p.call(this,e),this.messageType="MSG_POS_ECEF_COV",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="MSG_POS_ECEF_COV",u.prototype.msg_type=532,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),u.prototype.fieldSpec.push(["x","writeDoubleLE",8]),u.prototype.fieldSpec.push(["y","writeDoubleLE",8]),u.prototype.fieldSpec.push(["z","writeDoubleLE",8]),u.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),u.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),u.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),u.prototype.fieldSpec.push(["flags","writeUInt8",1]);var y=function(e,t){return p.call(this,e),this.messageType="MSG_POS_LLH",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="MSG_POS_LLH",y.prototype.msg_type=522,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),y.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),y.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),y.prototype.fieldSpec.push(["height","writeDoubleLE",8]),y.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),y.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),y.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),y.prototype.fieldSpec.push(["flags","writeUInt8",1]);var h=function(e,t){return p.call(this,e),this.messageType="MSG_POS_LLH_COV",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_POS_LLH_COV",h.prototype.msg_type=529,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").floatle("cov_n_n").floatle("cov_n_e").floatle("cov_n_d").floatle("cov_e_e").floatle("cov_e_d").floatle("cov_d_d").uint8("n_sats").uint8("flags"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),h.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),h.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),h.prototype.fieldSpec.push(["height","writeDoubleLE",8]),h.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),h.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),h.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),h.prototype.fieldSpec.push(["flags","writeUInt8",1]);var f=function(e,t){return p.call(this,e),this.messageType="EstimatedHorizontalErrorEllipse",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="EstimatedHorizontalErrorEllipse",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").floatle("semi_major").floatle("semi_minor").floatle("orientation"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["semi_major","writeFloatLE",4]),f.prototype.fieldSpec.push(["semi_minor","writeFloatLE",4]),f.prototype.fieldSpec.push(["orientation","writeFloatLE",4]);var d=function(e,t){return p.call(this,e),this.messageType="MSG_POS_LLH_ACC",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(p.prototype)).messageType="MSG_POS_LLH_ACC",d.prototype.msg_type=536,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").doublele("orthometric_height").floatle("h_accuracy").floatle("v_accuracy").floatle("ct_accuracy").floatle("at_accuracy").nest("h_ellipse",{type:f.prototype.parser}).uint8("confidence_and_geoid").uint8("n_sats").uint8("flags"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),d.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),d.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),d.prototype.fieldSpec.push(["height","writeDoubleLE",8]),d.prototype.fieldSpec.push(["orthometric_height","writeDoubleLE",8]),d.prototype.fieldSpec.push(["h_accuracy","writeFloatLE",4]),d.prototype.fieldSpec.push(["v_accuracy","writeFloatLE",4]),d.prototype.fieldSpec.push(["ct_accuracy","writeFloatLE",4]),d.prototype.fieldSpec.push(["at_accuracy","writeFloatLE",4]),d.prototype.fieldSpec.push(["h_ellipse",f.prototype.fieldSpec]),d.prototype.fieldSpec.push(["confidence_and_geoid","writeUInt8",1]),d.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),d.prototype.fieldSpec.push(["flags","writeUInt8",1]);var _=function(e,t){return p.call(this,e),this.messageType="MSG_BASELINE_ECEF",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(p.prototype)).messageType="MSG_BASELINE_ECEF",_.prototype.msg_type=523,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),_.prototype.fieldSpec.push(["x","writeInt32LE",4]),_.prototype.fieldSpec.push(["y","writeInt32LE",4]),_.prototype.fieldSpec.push(["z","writeInt32LE",4]),_.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),_.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),_.prototype.fieldSpec.push(["flags","writeUInt8",1]);var S=function(e,t){return p.call(this,e),this.messageType="MSG_BASELINE_NED",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(p.prototype)).messageType="MSG_BASELINE_NED",S.prototype.msg_type=524,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),S.prototype.fieldSpec.push(["n","writeInt32LE",4]),S.prototype.fieldSpec.push(["e","writeInt32LE",4]),S.prototype.fieldSpec.push(["d","writeInt32LE",4]),S.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),S.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),S.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),S.prototype.fieldSpec.push(["flags","writeUInt8",1]);var g=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_ECEF",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(p.prototype)).messageType="MSG_VEL_ECEF",g.prototype.msg_type=525,g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),g.prototype.fieldSpec.push(["x","writeInt32LE",4]),g.prototype.fieldSpec.push(["y","writeInt32LE",4]),g.prototype.fieldSpec.push(["z","writeInt32LE",4]),g.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),g.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),g.prototype.fieldSpec.push(["flags","writeUInt8",1]);var w=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_ECEF_COV",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(p.prototype)).messageType="MSG_VEL_ECEF_COV",w.prototype.msg_type=533,w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),w.prototype.fieldSpec.push(["x","writeInt32LE",4]),w.prototype.fieldSpec.push(["y","writeInt32LE",4]),w.prototype.fieldSpec.push(["z","writeInt32LE",4]),w.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),w.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),w.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),w.prototype.fieldSpec.push(["flags","writeUInt8",1]);var E=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_NED",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(p.prototype)).messageType="MSG_VEL_NED",E.prototype.msg_type=526,E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),E.prototype.fieldSpec.push(["n","writeInt32LE",4]),E.prototype.fieldSpec.push(["e","writeInt32LE",4]),E.prototype.fieldSpec.push(["d","writeInt32LE",4]),E.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),E.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),E.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),E.prototype.fieldSpec.push(["flags","writeUInt8",1]);var m=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_NED_COV",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(p.prototype)).messageType="MSG_VEL_NED_COV",m.prototype.msg_type=530,m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").floatle("cov_n_n").floatle("cov_n_e").floatle("cov_n_d").floatle("cov_e_e").floatle("cov_e_d").floatle("cov_d_d").uint8("n_sats").uint8("flags"),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),m.prototype.fieldSpec.push(["n","writeInt32LE",4]),m.prototype.fieldSpec.push(["e","writeInt32LE",4]),m.prototype.fieldSpec.push(["d","writeInt32LE",4]),m.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),m.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),m.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),m.prototype.fieldSpec.push(["flags","writeUInt8",1]);var b=function(e,t){return p.call(this,e),this.messageType="MSG_POS_ECEF_GNSS",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(p.prototype)).messageType="MSG_POS_ECEF_GNSS",b.prototype.msg_type=553,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").uint16("accuracy").uint8("n_sats").uint8("flags"),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),b.prototype.fieldSpec.push(["x","writeDoubleLE",8]),b.prototype.fieldSpec.push(["y","writeDoubleLE",8]),b.prototype.fieldSpec.push(["z","writeDoubleLE",8]),b.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),b.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),b.prototype.fieldSpec.push(["flags","writeUInt8",1]);var v=function(e,t){return p.call(this,e),this.messageType="MSG_POS_ECEF_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(p.prototype)).messageType="MSG_POS_ECEF_COV_GNSS",v.prototype.msg_type=564,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),v.prototype.fieldSpec.push(["x","writeDoubleLE",8]),v.prototype.fieldSpec.push(["y","writeDoubleLE",8]),v.prototype.fieldSpec.push(["z","writeDoubleLE",8]),v.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),v.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),v.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),v.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),v.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),v.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),v.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),v.prototype.fieldSpec.push(["flags","writeUInt8",1]);var I=function(e,t){return p.call(this,e),this.messageType="MSG_POS_LLH_GNSS",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(p.prototype)).messageType="MSG_POS_LLH_GNSS",I.prototype.msg_type=554,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),I.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),I.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),I.prototype.fieldSpec.push(["height","writeDoubleLE",8]),I.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),I.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),I.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),I.prototype.fieldSpec.push(["flags","writeUInt8",1]);var L=function(e,t){return p.call(this,e),this.messageType="MSG_POS_LLH_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(p.prototype)).messageType="MSG_POS_LLH_COV_GNSS",L.prototype.msg_type=561,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").floatle("cov_n_n").floatle("cov_n_e").floatle("cov_n_d").floatle("cov_e_e").floatle("cov_e_d").floatle("cov_d_d").uint8("n_sats").uint8("flags"),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),L.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),L.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),L.prototype.fieldSpec.push(["height","writeDoubleLE",8]),L.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),L.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),L.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),L.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),L.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),L.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),L.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),L.prototype.fieldSpec.push(["flags","writeUInt8",1]);var T=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_ECEF_GNSS",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(p.prototype)).messageType="MSG_VEL_ECEF_GNSS",T.prototype.msg_type=557,T.prototype.constructor=T,T.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),T.prototype.fieldSpec.push(["x","writeInt32LE",4]),T.prototype.fieldSpec.push(["y","writeInt32LE",4]),T.prototype.fieldSpec.push(["z","writeInt32LE",4]),T.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),T.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),T.prototype.fieldSpec.push(["flags","writeUInt8",1]);var U=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_ECEF_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(p.prototype)).messageType="MSG_VEL_ECEF_COV_GNSS",U.prototype.msg_type=565,U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),U.prototype.fieldSpec.push(["x","writeInt32LE",4]),U.prototype.fieldSpec.push(["y","writeInt32LE",4]),U.prototype.fieldSpec.push(["z","writeInt32LE",4]),U.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),U.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),U.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),U.prototype.fieldSpec.push(["flags","writeUInt8",1]);var M=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_NED_GNSS",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(p.prototype)).messageType="MSG_VEL_NED_GNSS",M.prototype.msg_type=558,M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),M.prototype.fieldSpec.push(["n","writeInt32LE",4]),M.prototype.fieldSpec.push(["e","writeInt32LE",4]),M.prototype.fieldSpec.push(["d","writeInt32LE",4]),M.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),M.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),M.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),M.prototype.fieldSpec.push(["flags","writeUInt8",1]);var D=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_NED_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(p.prototype)).messageType="MSG_VEL_NED_COV_GNSS",D.prototype.msg_type=562,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").floatle("cov_n_n").floatle("cov_n_e").floatle("cov_n_d").floatle("cov_e_e").floatle("cov_e_d").floatle("cov_d_d").uint8("n_sats").uint8("flags"),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),D.prototype.fieldSpec.push(["n","writeInt32LE",4]),D.prototype.fieldSpec.push(["e","writeInt32LE",4]),D.prototype.fieldSpec.push(["d","writeInt32LE",4]),D.prototype.fieldSpec.push(["cov_n_n","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_n_e","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_n_d","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_e_e","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_e_d","writeFloatLE",4]),D.prototype.fieldSpec.push(["cov_d_d","writeFloatLE",4]),D.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),D.prototype.fieldSpec.push(["flags","writeUInt8",1]);var O=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_BODY",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(p.prototype)).messageType="MSG_VEL_BODY",O.prototype.msg_type=531,O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").floatle("cov_x_x").floatle("cov_x_y").floatle("cov_x_z").floatle("cov_y_y").floatle("cov_y_z").floatle("cov_z_z").uint8("n_sats").uint8("flags"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),O.prototype.fieldSpec.push(["x","writeInt32LE",4]),O.prototype.fieldSpec.push(["y","writeInt32LE",4]),O.prototype.fieldSpec.push(["z","writeInt32LE",4]),O.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),O.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),O.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),O.prototype.fieldSpec.push(["flags","writeUInt8",1]);var G=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_COG",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(p.prototype)).messageType="MSG_VEL_COG",G.prototype.msg_type=540,G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").uint32("tow").uint32("cog").uint32("sog").int32("v_up").uint32("cog_accuracy").uint32("sog_accuracy").uint32("v_up_accuracy").uint16("flags"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),G.prototype.fieldSpec.push(["cog","writeUInt32LE",4]),G.prototype.fieldSpec.push(["sog","writeUInt32LE",4]),G.prototype.fieldSpec.push(["v_up","writeInt32LE",4]),G.prototype.fieldSpec.push(["cog_accuracy","writeUInt32LE",4]),G.prototype.fieldSpec.push(["sog_accuracy","writeUInt32LE",4]),G.prototype.fieldSpec.push(["v_up_accuracy","writeUInt32LE",4]),G.prototype.fieldSpec.push(["flags","writeUInt16LE",2]);var A=function(e,t){return p.call(this,e),this.messageType="MSG_AGE_CORRECTIONS",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(p.prototype)).messageType="MSG_AGE_CORRECTIONS",A.prototype.msg_type=528,A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").uint32("tow").uint16("age"),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),A.prototype.fieldSpec.push(["age","writeUInt16LE",2]);var C=function(e,t){return p.call(this,e),this.messageType="MSG_GPS_TIME_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(p.prototype)).messageType="MSG_GPS_TIME_DEP_A",C.prototype.msg_type=256,C.prototype.constructor=C,C.prototype.parser=(new o).endianess("little").uint16("wn").uint32("tow").int32("ns_residual").uint8("flags"),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),C.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),C.prototype.fieldSpec.push(["ns_residual","writeInt32LE",4]),C.prototype.fieldSpec.push(["flags","writeUInt8",1]);var R=function(e,t){return p.call(this,e),this.messageType="MSG_DOPS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(p.prototype)).messageType="MSG_DOPS_DEP_A",R.prototype.msg_type=518,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").uint32("tow").uint16("gdop").uint16("pdop").uint16("tdop").uint16("hdop").uint16("vdop"),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),R.prototype.fieldSpec.push(["gdop","writeUInt16LE",2]),R.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),R.prototype.fieldSpec.push(["tdop","writeUInt16LE",2]),R.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),R.prototype.fieldSpec.push(["vdop","writeUInt16LE",2]);var P=function(e,t){return p.call(this,e),this.messageType="MSG_POS_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(p.prototype)).messageType="MSG_POS_ECEF_DEP_A",P.prototype.msg_type=512,P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").uint32("tow").doublele("x").doublele("y").doublele("z").uint16("accuracy").uint8("n_sats").uint8("flags"),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),P.prototype.fieldSpec.push(["x","writeDoubleLE",8]),P.prototype.fieldSpec.push(["y","writeDoubleLE",8]),P.prototype.fieldSpec.push(["z","writeDoubleLE",8]),P.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),P.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),P.prototype.fieldSpec.push(["flags","writeUInt8",1]);var N=function(e,t){return p.call(this,e),this.messageType="MSG_POS_LLH_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(p.prototype)).messageType="MSG_POS_LLH_DEP_A",N.prototype.msg_type=513,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").uint32("tow").doublele("lat").doublele("lon").doublele("height").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),N.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),N.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),N.prototype.fieldSpec.push(["height","writeDoubleLE",8]),N.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),N.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),N.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),N.prototype.fieldSpec.push(["flags","writeUInt8",1]);var j=function(e,t){return p.call(this,e),this.messageType="MSG_BASELINE_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(p.prototype)).messageType="MSG_BASELINE_ECEF_DEP_A",j.prototype.msg_type=514,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),j.prototype.fieldSpec.push(["x","writeInt32LE",4]),j.prototype.fieldSpec.push(["y","writeInt32LE",4]),j.prototype.fieldSpec.push(["z","writeInt32LE",4]),j.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),j.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),j.prototype.fieldSpec.push(["flags","writeUInt8",1]);var x=function(e,t){return p.call(this,e),this.messageType="MSG_BASELINE_NED_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(p.prototype)).messageType="MSG_BASELINE_NED_DEP_A",x.prototype.msg_type=515,x.prototype.constructor=x,x.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),x.prototype.fieldSpec=[],x.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),x.prototype.fieldSpec.push(["n","writeInt32LE",4]),x.prototype.fieldSpec.push(["e","writeInt32LE",4]),x.prototype.fieldSpec.push(["d","writeInt32LE",4]),x.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),x.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),x.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),x.prototype.fieldSpec.push(["flags","writeUInt8",1]);var F=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(p.prototype)).messageType="MSG_VEL_ECEF_DEP_A",F.prototype.msg_type=516,F.prototype.constructor=F,F.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint16("accuracy").uint8("n_sats").uint8("flags"),F.prototype.fieldSpec=[],F.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),F.prototype.fieldSpec.push(["x","writeInt32LE",4]),F.prototype.fieldSpec.push(["y","writeInt32LE",4]),F.prototype.fieldSpec.push(["z","writeInt32LE",4]),F.prototype.fieldSpec.push(["accuracy","writeUInt16LE",2]),F.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),F.prototype.fieldSpec.push(["flags","writeUInt8",1]);var k=function(e,t){return p.call(this,e),this.messageType="MSG_VEL_NED_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(p.prototype)).messageType="MSG_VEL_NED_DEP_A",k.prototype.msg_type=517,k.prototype.constructor=k,k.prototype.parser=(new o).endianess("little").uint32("tow").int32("n").int32("e").int32("d").uint16("h_accuracy").uint16("v_accuracy").uint8("n_sats").uint8("flags"),k.prototype.fieldSpec=[],k.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),k.prototype.fieldSpec.push(["n","writeInt32LE",4]),k.prototype.fieldSpec.push(["e","writeInt32LE",4]),k.prototype.fieldSpec.push(["d","writeInt32LE",4]),k.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),k.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),k.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),k.prototype.fieldSpec.push(["flags","writeUInt8",1]);var B=function(e,t){return p.call(this,e),this.messageType="MSG_BASELINE_HEADING_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(B.prototype=Object.create(p.prototype)).messageType="MSG_BASELINE_HEADING_DEP_A",B.prototype.msg_type=519,B.prototype.constructor=B,B.prototype.parser=(new o).endianess("little").uint32("tow").uint32("heading").uint8("n_sats").uint8("flags"),B.prototype.fieldSpec=[],B.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),B.prototype.fieldSpec.push(["heading","writeUInt32LE",4]),B.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),B.prototype.fieldSpec.push(["flags","writeUInt8",1]);var q=function(e,t){return p.call(this,e),this.messageType="MSG_PROTECTION_LEVEL_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(p.prototype)).messageType="MSG_PROTECTION_LEVEL_DEP_A",q.prototype.msg_type=534,q.prototype.constructor=q,q.prototype.parser=(new o).endianess("little").uint32("tow").uint16("vpl").uint16("hpl").doublele("lat").doublele("lon").doublele("height").uint8("flags"),q.prototype.fieldSpec=[],q.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),q.prototype.fieldSpec.push(["vpl","writeUInt16LE",2]),q.prototype.fieldSpec.push(["hpl","writeUInt16LE",2]),q.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),q.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),q.prototype.fieldSpec.push(["height","writeDoubleLE",8]),q.prototype.fieldSpec.push(["flags","writeUInt8",1]);var z=function(e,t){return p.call(this,e),this.messageType="MSG_PROTECTION_LEVEL",this.fields=t||this.parser.parse(e.payload),this};(z.prototype=Object.create(p.prototype)).messageType="MSG_PROTECTION_LEVEL",z.prototype.msg_type=535,z.prototype.constructor=z,z.prototype.parser=(new o).endianess("little").uint32("tow").int16("wn").uint16("hpl").uint16("vpl").uint16("atpl").uint16("ctpl").uint16("hvpl").uint16("vvpl").uint16("hopl").uint16("popl").uint16("ropl").doublele("lat").doublele("lon").doublele("height").int32("v_x").int32("v_y").int32("v_z").int32("roll").int32("pitch").int32("heading").uint32("flags"),z.prototype.fieldSpec=[],z.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),z.prototype.fieldSpec.push(["wn","writeInt16LE",2]),z.prototype.fieldSpec.push(["hpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["vpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["atpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["ctpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["hvpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["vvpl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["hopl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["popl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["ropl","writeUInt16LE",2]),z.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),z.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),z.prototype.fieldSpec.push(["height","writeDoubleLE",8]),z.prototype.fieldSpec.push(["v_x","writeInt32LE",4]),z.prototype.fieldSpec.push(["v_y","writeInt32LE",4]),z.prototype.fieldSpec.push(["v_z","writeInt32LE",4]),z.prototype.fieldSpec.push(["roll","writeInt32LE",4]),z.prototype.fieldSpec.push(["pitch","writeInt32LE",4]),z.prototype.fieldSpec.push(["heading","writeInt32LE",4]),z.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);var H=function(e,t){return p.call(this,e),this.messageType="MSG_GPS_LEAP_SECOND",this.fields=t||this.parser.parse(e.payload),this};(H.prototype=Object.create(p.prototype)).messageType="MSG_GPS_LEAP_SECOND",H.prototype.msg_type=570,H.prototype.constructor=H,H.prototype.parser=(new o).endianess("little").array("stub",{type:"uint8",readUntil:"eof"}),H.prototype.fieldSpec=[],H.prototype.fieldSpec.push(["stub","array","writeUInt8",function(){return 1},null]);var V=function(e,t){return p.call(this,e),this.messageType="MSG_ITRF",this.fields=t||this.parser.parse(e.payload),this};(V.prototype=Object.create(p.prototype)).messageType="MSG_ITRF",V.prototype.msg_type=580,V.prototype.constructor=V,V.prototype.parser=(new o).endianess("little").array("stub",{type:"uint8",readUntil:"eof"}),V.prototype.fieldSpec=[],V.prototype.fieldSpec.push(["stub","array","writeUInt8",function(){return 1},null]),e.exports={258:i,MsgGpsTime:i,260:s,MsgGpsTimeGnss:s,259:n,MsgUtcTime:n,261:a,MsgUtcTimeGnss:a,520:l,MsgDops:l,521:c,MsgPosEcef:c,532:u,MsgPosEcefCov:u,522:y,MsgPosLlh:y,529:h,MsgPosLlhCov:h,EstimatedHorizontalErrorEllipse:f,536:d,MsgPosLlhAcc:d,523:_,MsgBaselineEcef:_,524:S,MsgBaselineNed:S,525:g,MsgVelEcef:g,533:w,MsgVelEcefCov:w,526:E,MsgVelNed:E,530:m,MsgVelNedCov:m,553:b,MsgPosEcefGnss:b,564:v,MsgPosEcefCovGnss:v,554:I,MsgPosLlhGnss:I,561:L,MsgPosLlhCovGnss:L,557:T,MsgVelEcefGnss:T,565:U,MsgVelEcefCovGnss:U,558:M,MsgVelNedGnss:M,562:D,MsgVelNedCovGnss:D,531:O,MsgVelBody:O,540:G,MsgVelCog:G,528:A,MsgAgeCorrections:A,256:C,MsgGpsTimeDepA:C,518:R,MsgDopsDepA:R,512:P,MsgPosEcefDepA:P,513:N,MsgPosLlhDepA:N,514:j,MsgBaselineEcefDepA:j,515:x,MsgBaselineNedDepA:x,516:F,MsgVelEcefDepA:F,517:k,MsgVelNedDepA:k,519:B,MsgBaselineHeadingDepA:B,534:q,MsgProtectionLevelDepA:q,535:z,MsgProtectionLevel:z,570:H,MsgGpsLeapSecond:H,580:V,MsgItrf:V}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,r(0).CarrierPhase,r(0).GnssSignal),s=(r(0).GnssSignalDep,r(0).GPSTime,r(0).GPSTimeDep,r(0).GPSTimeSec,r(0).SvId,function(e,t){return p.call(this,e),this.messageType="MSG_NDB_EVENT",this.fields=t||this.parser.parse(e.payload),this});(s.prototype=Object.create(p.prototype)).messageType="MSG_NDB_EVENT",s.prototype.msg_type=1024,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint64("recv_time").uint8("event").uint8("object_type").uint8("result").uint8("data_source").nest("object_sid",{type:i.prototype.parser}).nest("src_sid",{type:i.prototype.parser}).uint16("original_sender"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["recv_time","writeUInt64LE",8]),s.prototype.fieldSpec.push(["event","writeUInt8",1]),s.prototype.fieldSpec.push(["object_type","writeUInt8",1]),s.prototype.fieldSpec.push(["result","writeUInt8",1]),s.prototype.fieldSpec.push(["data_source","writeUInt8",1]),s.prototype.fieldSpec.push(["object_sid",i.prototype.fieldSpec]),s.prototype.fieldSpec.push(["src_sid",i.prototype.fieldSpec]),s.prototype.fieldSpec.push(["original_sender","writeUInt16LE",2]),e.exports={1024:s,MsgNdbEvent:s}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,r(0).CarrierPhase),s=r(0).GnssSignal,n=r(0).GnssSignalDep,a=r(0).GPSTime,l=r(0).GPSTimeDep,c=r(0).GPSTimeSec,u=(r(0).SvId,function(e,t){return p.call(this,e),this.messageType="ObservationHeader",this.fields=t||this.parser.parse(e.payload),this});(u.prototype=Object.create(p.prototype)).messageType="ObservationHeader",u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").nest("t",{type:a.prototype.parser}).uint8("n_obs"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["t",a.prototype.fieldSpec]),u.prototype.fieldSpec.push(["n_obs","writeUInt8",1]);var y=function(e,t){return p.call(this,e),this.messageType="Doppler",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="Doppler",y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").int16("i").uint8("f"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["i","writeInt16LE",2]),y.prototype.fieldSpec.push(["f","writeUInt8",1]);var h=function(e,t){return p.call(this,e),this.messageType="PackedObsContent",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="PackedObsContent",h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:i.prototype.parser}).nest("D",{type:y.prototype.parser}).uint8("cn0").uint8("lock").uint8("flags").nest("sid",{type:s.prototype.parser}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["P","writeUInt32LE",4]),h.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),h.prototype.fieldSpec.push(["D",y.prototype.fieldSpec]),h.prototype.fieldSpec.push(["cn0","writeUInt8",1]),h.prototype.fieldSpec.push(["lock","writeUInt8",1]),h.prototype.fieldSpec.push(["flags","writeUInt8",1]),h.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);var f=function(e,t){return p.call(this,e),this.messageType="PackedOsrContent",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="PackedOsrContent",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:i.prototype.parser}).uint8("lock").uint8("flags").nest("sid",{type:s.prototype.parser}).uint16("iono_std").uint16("tropo_std").uint16("range_std"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["P","writeUInt32LE",4]),f.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),f.prototype.fieldSpec.push(["lock","writeUInt8",1]),f.prototype.fieldSpec.push(["flags","writeUInt8",1]),f.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),f.prototype.fieldSpec.push(["iono_std","writeUInt16LE",2]),f.prototype.fieldSpec.push(["tropo_std","writeUInt16LE",2]),f.prototype.fieldSpec.push(["range_std","writeUInt16LE",2]);var d=function(e,t){return p.call(this,e),this.messageType="MSG_OBS",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(p.prototype)).messageType="MSG_OBS",d.prototype.msg_type=74,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").nest("header",{type:u.prototype.parser}).array("obs",{type:h.prototype.parser,readUntil:"eof"}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["header",u.prototype.fieldSpec]),d.prototype.fieldSpec.push(["obs","array",h.prototype.fieldSpec,function(){return this.fields.array.length},null]);var _=function(e,t){return p.call(this,e),this.messageType="MSG_BASE_POS_LLH",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(p.prototype)).messageType="MSG_BASE_POS_LLH",_.prototype.msg_type=68,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").doublele("lat").doublele("lon").doublele("height"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),_.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),_.prototype.fieldSpec.push(["height","writeDoubleLE",8]);var S=function(e,t){return p.call(this,e),this.messageType="MSG_BASE_POS_ECEF",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(p.prototype)).messageType="MSG_BASE_POS_ECEF",S.prototype.msg_type=72,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").doublele("x").doublele("y").doublele("z"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["x","writeDoubleLE",8]),S.prototype.fieldSpec.push(["y","writeDoubleLE",8]),S.prototype.fieldSpec.push(["z","writeDoubleLE",8]);var g=function(e,t){return p.call(this,e),this.messageType="EphemerisCommonContent",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(p.prototype)).messageType="EphemerisCommonContent",g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).nest("toe",{type:c.prototype.parser}).floatle("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),g.prototype.fieldSpec.push(["toe",c.prototype.fieldSpec]),g.prototype.fieldSpec.push(["ura","writeFloatLE",4]),g.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),g.prototype.fieldSpec.push(["valid","writeUInt8",1]),g.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);var w=function(e,t){return p.call(this,e),this.messageType="EphemerisCommonContentDepB",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(p.prototype)).messageType="EphemerisCommonContentDepB",w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).nest("toe",{type:c.prototype.parser}).doublele("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),w.prototype.fieldSpec.push(["toe",c.prototype.fieldSpec]),w.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),w.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),w.prototype.fieldSpec.push(["valid","writeUInt8",1]),w.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);var E=function(e,t){return p.call(this,e),this.messageType="EphemerisCommonContentDepA",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(p.prototype)).messageType="EphemerisCommonContentDepA",E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").nest("sid",{type:n.prototype.parser}).nest("toe",{type:l.prototype.parser}).doublele("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),E.prototype.fieldSpec.push(["toe",l.prototype.fieldSpec]),E.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),E.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),E.prototype.fieldSpec.push(["valid","writeUInt8",1]),E.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);var m=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GPS_DEP_E",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GPS_DEP_E",m.prototype.msg_type=129,m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").nest("common",{type:E.prototype.parser}).doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").nest("toc",{type:l.prototype.parser}).uint8("iode").uint16("iodc"),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["common",E.prototype.fieldSpec]),m.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),m.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),m.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),m.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),m.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),m.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),m.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),m.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),m.prototype.fieldSpec.push(["w","writeDoubleLE",8]),m.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),m.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),m.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),m.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),m.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),m.prototype.fieldSpec.push(["toc",l.prototype.fieldSpec]),m.prototype.fieldSpec.push(["iode","writeUInt8",1]),m.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);var b=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GPS_DEP_F",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GPS_DEP_F",b.prototype.msg_type=134,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").nest("toc",{type:c.prototype.parser}).uint8("iode").uint16("iodc"),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),b.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),b.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),b.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),b.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),b.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),b.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),b.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),b.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),b.prototype.fieldSpec.push(["w","writeDoubleLE",8]),b.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),b.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),b.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),b.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),b.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),b.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),b.prototype.fieldSpec.push(["iode","writeUInt8",1]),b.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);var v=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GPS",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GPS",v.prototype.msg_type=138,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("tgd").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").floatle("af0").floatle("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint8("iode").uint16("iodc"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),v.prototype.fieldSpec.push(["tgd","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),v.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),v.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),v.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),v.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),v.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),v.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),v.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),v.prototype.fieldSpec.push(["w","writeDoubleLE",8]),v.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),v.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),v.prototype.fieldSpec.push(["af0","writeFloatLE",4]),v.prototype.fieldSpec.push(["af1","writeFloatLE",4]),v.prototype.fieldSpec.push(["af2","writeFloatLE",4]),v.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),v.prototype.fieldSpec.push(["iode","writeUInt8",1]),v.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);var I=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_QZSS",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_QZSS",I.prototype.msg_type=142,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("tgd").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").floatle("af0").floatle("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint8("iode").uint16("iodc"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),I.prototype.fieldSpec.push(["tgd","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),I.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),I.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),I.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),I.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),I.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),I.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),I.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),I.prototype.fieldSpec.push(["w","writeDoubleLE",8]),I.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),I.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),I.prototype.fieldSpec.push(["af0","writeFloatLE",4]),I.prototype.fieldSpec.push(["af1","writeFloatLE",4]),I.prototype.fieldSpec.push(["af2","writeFloatLE",4]),I.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),I.prototype.fieldSpec.push(["iode","writeUInt8",1]),I.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);var L=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_BDS",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_BDS",L.prototype.msg_type=137,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("tgd1").floatle("tgd2").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").floatle("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint8("iode").uint16("iodc"),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),L.prototype.fieldSpec.push(["tgd1","writeFloatLE",4]),L.prototype.fieldSpec.push(["tgd2","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),L.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),L.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),L.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),L.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),L.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),L.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),L.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),L.prototype.fieldSpec.push(["w","writeDoubleLE",8]),L.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),L.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),L.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),L.prototype.fieldSpec.push(["af1","writeFloatLE",4]),L.prototype.fieldSpec.push(["af2","writeFloatLE",4]),L.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),L.prototype.fieldSpec.push(["iode","writeUInt8",1]),L.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);var T=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GAL_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GAL_DEP_A",T.prototype.msg_type=149,T.prototype.constructor=T,T.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("bgd_e1e5a").floatle("bgd_e1e5b").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint16("iode").uint16("iodc"),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),T.prototype.fieldSpec.push(["bgd_e1e5a","writeFloatLE",4]),T.prototype.fieldSpec.push(["bgd_e1e5b","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),T.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),T.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),T.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),T.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),T.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),T.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),T.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),T.prototype.fieldSpec.push(["w","writeDoubleLE",8]),T.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),T.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),T.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),T.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),T.prototype.fieldSpec.push(["af2","writeFloatLE",4]),T.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),T.prototype.fieldSpec.push(["iode","writeUInt16LE",2]),T.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]);var U=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GAL",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GAL",U.prototype.msg_type=141,U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("bgd_e1e5a").floatle("bgd_e1e5b").floatle("c_rs").floatle("c_rc").floatle("c_uc").floatle("c_us").floatle("c_ic").floatle("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").floatle("af2").nest("toc",{type:c.prototype.parser}).uint16("iode").uint16("iodc").uint8("source"),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),U.prototype.fieldSpec.push(["bgd_e1e5a","writeFloatLE",4]),U.prototype.fieldSpec.push(["bgd_e1e5b","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_rs","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_rc","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_uc","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_us","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_ic","writeFloatLE",4]),U.prototype.fieldSpec.push(["c_is","writeFloatLE",4]),U.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),U.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),U.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),U.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),U.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),U.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),U.prototype.fieldSpec.push(["w","writeDoubleLE",8]),U.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),U.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),U.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),U.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),U.prototype.fieldSpec.push(["af2","writeFloatLE",4]),U.prototype.fieldSpec.push(["toc",c.prototype.fieldSpec]),U.prototype.fieldSpec.push(["iode","writeUInt16LE",2]),U.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]),U.prototype.fieldSpec.push(["source","writeUInt8",1]);var M=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_SBAS_DEP_A",M.prototype.msg_type=130,M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").nest("common",{type:E.prototype.parser}).array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}).doublele("a_gf0").doublele("a_gf1"),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["common",E.prototype.fieldSpec]),M.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),M.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),M.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),M.prototype.fieldSpec.push(["a_gf0","writeDoubleLE",8]),M.prototype.fieldSpec.push(["a_gf1","writeDoubleLE",8]);var D=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_A",D.prototype.msg_type=131,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").nest("common",{type:E.prototype.parser}).doublele("gamma").doublele("tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["common",E.prototype.fieldSpec]),D.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),D.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),D.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),D.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),D.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]);var O=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_SBAS_DEP_B",O.prototype.msg_type=132,O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}).doublele("a_gf0").doublele("a_gf1"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),O.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),O.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),O.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),O.prototype.fieldSpec.push(["a_gf0","writeDoubleLE",8]),O.prototype.fieldSpec.push(["a_gf1","writeDoubleLE",8]);var G=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_SBAS",G.prototype.msg_type=140,G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"floatle"}).array("acc",{length:3,type:"floatle"}).floatle("a_gf0").floatle("a_gf1"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),G.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),G.prototype.fieldSpec.push(["vel","array","writeFloatLE",function(){return 4},3]),G.prototype.fieldSpec.push(["acc","array","writeFloatLE",function(){return 4},3]),G.prototype.fieldSpec.push(["a_gf0","writeFloatLE",4]),G.prototype.fieldSpec.push(["a_gf1","writeFloatLE",4]);var A=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_B",A.prototype.msg_type=133,A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).doublele("gamma").doublele("tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),A.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),A.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),A.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),A.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),A.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]);var C=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_C",C.prototype.msg_type=135,C.prototype.constructor=C,C.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).doublele("gamma").doublele("tau").doublele("d_tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}).uint8("fcn"),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),C.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),C.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),C.prototype.fieldSpec.push(["d_tau","writeDoubleLE",8]),C.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),C.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),C.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),C.prototype.fieldSpec.push(["fcn","writeUInt8",1]);var R=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_D",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GLO_DEP_D",R.prototype.msg_type=136,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").nest("common",{type:w.prototype.parser}).doublele("gamma").doublele("tau").doublele("d_tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"doublele"}).uint8("fcn").uint8("iod"),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["common",w.prototype.fieldSpec]),R.prototype.fieldSpec.push(["gamma","writeDoubleLE",8]),R.prototype.fieldSpec.push(["tau","writeDoubleLE",8]),R.prototype.fieldSpec.push(["d_tau","writeDoubleLE",8]),R.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),R.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),R.prototype.fieldSpec.push(["acc","array","writeDoubleLE",function(){return 8},3]),R.prototype.fieldSpec.push(["fcn","writeUInt8",1]),R.prototype.fieldSpec.push(["iod","writeUInt8",1]);var P=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_GLO",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_GLO",P.prototype.msg_type=139,P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").nest("common",{type:g.prototype.parser}).floatle("gamma").floatle("tau").floatle("d_tau").array("pos",{length:3,type:"doublele"}).array("vel",{length:3,type:"doublele"}).array("acc",{length:3,type:"floatle"}).uint8("fcn").uint8("iod"),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["common",g.prototype.fieldSpec]),P.prototype.fieldSpec.push(["gamma","writeFloatLE",4]),P.prototype.fieldSpec.push(["tau","writeFloatLE",4]),P.prototype.fieldSpec.push(["d_tau","writeFloatLE",4]),P.prototype.fieldSpec.push(["pos","array","writeDoubleLE",function(){return 8},3]),P.prototype.fieldSpec.push(["vel","array","writeDoubleLE",function(){return 8},3]),P.prototype.fieldSpec.push(["acc","array","writeFloatLE",function(){return 4},3]),P.prototype.fieldSpec.push(["fcn","writeUInt8",1]),P.prototype.fieldSpec.push(["iod","writeUInt8",1]);var N=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_D",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_DEP_D",N.prototype.msg_type=128,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").doublele("toe_tow").uint16("toe_wn").doublele("toc_tow").uint16("toc_wn").uint8("valid").uint8("healthy").nest("sid",{type:n.prototype.parser}).uint8("iode").uint16("iodc").uint32("reserved"),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),N.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),N.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),N.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),N.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),N.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),N.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),N.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),N.prototype.fieldSpec.push(["w","writeDoubleLE",8]),N.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),N.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),N.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),N.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),N.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),N.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),N.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),N.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),N.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),N.prototype.fieldSpec.push(["valid","writeUInt8",1]),N.prototype.fieldSpec.push(["healthy","writeUInt8",1]),N.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),N.prototype.fieldSpec.push(["iode","writeUInt8",1]),N.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]),N.prototype.fieldSpec.push(["reserved","writeUInt32LE",4]);var j=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_DEP_A",j.prototype.msg_type=26,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").doublele("toe_tow").uint16("toe_wn").doublele("toc_tow").uint16("toc_wn").uint8("valid").uint8("healthy").uint8("prn"),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),j.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),j.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),j.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),j.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),j.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),j.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),j.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),j.prototype.fieldSpec.push(["w","writeDoubleLE",8]),j.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),j.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),j.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),j.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),j.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),j.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),j.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),j.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),j.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),j.prototype.fieldSpec.push(["valid","writeUInt8",1]),j.prototype.fieldSpec.push(["healthy","writeUInt8",1]),j.prototype.fieldSpec.push(["prn","writeUInt8",1]);var x=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_DEP_B",x.prototype.msg_type=70,x.prototype.constructor=x,x.prototype.parser=(new o).endianess("little").doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").doublele("toe_tow").uint16("toe_wn").doublele("toc_tow").uint16("toc_wn").uint8("valid").uint8("healthy").uint8("prn").uint8("iode"),x.prototype.fieldSpec=[],x.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),x.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),x.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),x.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),x.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),x.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),x.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),x.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),x.prototype.fieldSpec.push(["w","writeDoubleLE",8]),x.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),x.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),x.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),x.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),x.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),x.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),x.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),x.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),x.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),x.prototype.fieldSpec.push(["valid","writeUInt8",1]),x.prototype.fieldSpec.push(["healthy","writeUInt8",1]),x.prototype.fieldSpec.push(["prn","writeUInt8",1]),x.prototype.fieldSpec.push(["iode","writeUInt8",1]);var F=function(e,t){return p.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(p.prototype)).messageType="MSG_EPHEMERIS_DEP_C",F.prototype.msg_type=71,F.prototype.constructor=F,F.prototype.parser=(new o).endianess("little").doublele("tgd").doublele("c_rs").doublele("c_rc").doublele("c_uc").doublele("c_us").doublele("c_ic").doublele("c_is").doublele("dn").doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("inc_dot").doublele("af0").doublele("af1").doublele("af2").doublele("toe_tow").uint16("toe_wn").doublele("toc_tow").uint16("toc_wn").uint8("valid").uint8("healthy").nest("sid",{type:n.prototype.parser}).uint8("iode").uint16("iodc").uint32("reserved"),F.prototype.fieldSpec=[],F.prototype.fieldSpec.push(["tgd","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_rs","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_rc","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_uc","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_us","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_ic","writeDoubleLE",8]),F.prototype.fieldSpec.push(["c_is","writeDoubleLE",8]),F.prototype.fieldSpec.push(["dn","writeDoubleLE",8]),F.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),F.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),F.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),F.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),F.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),F.prototype.fieldSpec.push(["w","writeDoubleLE",8]),F.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),F.prototype.fieldSpec.push(["inc_dot","writeDoubleLE",8]),F.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),F.prototype.fieldSpec.push(["af1","writeDoubleLE",8]),F.prototype.fieldSpec.push(["af2","writeDoubleLE",8]),F.prototype.fieldSpec.push(["toe_tow","writeDoubleLE",8]),F.prototype.fieldSpec.push(["toe_wn","writeUInt16LE",2]),F.prototype.fieldSpec.push(["toc_tow","writeDoubleLE",8]),F.prototype.fieldSpec.push(["toc_wn","writeUInt16LE",2]),F.prototype.fieldSpec.push(["valid","writeUInt8",1]),F.prototype.fieldSpec.push(["healthy","writeUInt8",1]),F.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),F.prototype.fieldSpec.push(["iode","writeUInt8",1]),F.prototype.fieldSpec.push(["iodc","writeUInt16LE",2]),F.prototype.fieldSpec.push(["reserved","writeUInt32LE",4]);var k=function(e,t){return p.call(this,e),this.messageType="ObservationHeaderDep",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(p.prototype)).messageType="ObservationHeaderDep",k.prototype.constructor=k,k.prototype.parser=(new o).endianess("little").nest("t",{type:l.prototype.parser}).uint8("n_obs"),k.prototype.fieldSpec=[],k.prototype.fieldSpec.push(["t",l.prototype.fieldSpec]),k.prototype.fieldSpec.push(["n_obs","writeUInt8",1]);var B=function(e,t){return p.call(this,e),this.messageType="CarrierPhaseDepA",this.fields=t||this.parser.parse(e.payload),this};(B.prototype=Object.create(p.prototype)).messageType="CarrierPhaseDepA",B.prototype.constructor=B,B.prototype.parser=(new o).endianess("little").int32("i").uint8("f"),B.prototype.fieldSpec=[],B.prototype.fieldSpec.push(["i","writeInt32LE",4]),B.prototype.fieldSpec.push(["f","writeUInt8",1]);var q=function(e,t){return p.call(this,e),this.messageType="PackedObsContentDepA",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(p.prototype)).messageType="PackedObsContentDepA",q.prototype.constructor=q,q.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:B.prototype.parser}).uint8("cn0").uint16("lock").uint8("prn"),q.prototype.fieldSpec=[],q.prototype.fieldSpec.push(["P","writeUInt32LE",4]),q.prototype.fieldSpec.push(["L",B.prototype.fieldSpec]),q.prototype.fieldSpec.push(["cn0","writeUInt8",1]),q.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),q.prototype.fieldSpec.push(["prn","writeUInt8",1]);var z=function(e,t){return p.call(this,e),this.messageType="PackedObsContentDepB",this.fields=t||this.parser.parse(e.payload),this};(z.prototype=Object.create(p.prototype)).messageType="PackedObsContentDepB",z.prototype.constructor=z,z.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:B.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:n.prototype.parser}),z.prototype.fieldSpec=[],z.prototype.fieldSpec.push(["P","writeUInt32LE",4]),z.prototype.fieldSpec.push(["L",B.prototype.fieldSpec]),z.prototype.fieldSpec.push(["cn0","writeUInt8",1]),z.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),z.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]);var H=function(e,t){return p.call(this,e),this.messageType="PackedObsContentDepC",this.fields=t||this.parser.parse(e.payload),this};(H.prototype=Object.create(p.prototype)).messageType="PackedObsContentDepC",H.prototype.constructor=H,H.prototype.parser=(new o).endianess("little").uint32("P").nest("L",{type:i.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:n.prototype.parser}),H.prototype.fieldSpec=[],H.prototype.fieldSpec.push(["P","writeUInt32LE",4]),H.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),H.prototype.fieldSpec.push(["cn0","writeUInt8",1]),H.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),H.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]);var V=function(e,t){return p.call(this,e),this.messageType="MSG_OBS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(V.prototype=Object.create(p.prototype)).messageType="MSG_OBS_DEP_A",V.prototype.msg_type=69,V.prototype.constructor=V,V.prototype.parser=(new o).endianess("little").nest("header",{type:k.prototype.parser}).array("obs",{type:q.prototype.parser,readUntil:"eof"}),V.prototype.fieldSpec=[],V.prototype.fieldSpec.push(["header",k.prototype.fieldSpec]),V.prototype.fieldSpec.push(["obs","array",q.prototype.fieldSpec,function(){return this.fields.array.length},null]);var Y=function(e,t){return p.call(this,e),this.messageType="MSG_OBS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(Y.prototype=Object.create(p.prototype)).messageType="MSG_OBS_DEP_B",Y.prototype.msg_type=67,Y.prototype.constructor=Y,Y.prototype.parser=(new o).endianess("little").nest("header",{type:k.prototype.parser}).array("obs",{type:z.prototype.parser,readUntil:"eof"}),Y.prototype.fieldSpec=[],Y.prototype.fieldSpec.push(["header",k.prototype.fieldSpec]),Y.prototype.fieldSpec.push(["obs","array",z.prototype.fieldSpec,function(){return this.fields.array.length},null]);var W=function(e,t){return p.call(this,e),this.messageType="MSG_OBS_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(W.prototype=Object.create(p.prototype)).messageType="MSG_OBS_DEP_C",W.prototype.msg_type=73,W.prototype.constructor=W,W.prototype.parser=(new o).endianess("little").nest("header",{type:k.prototype.parser}).array("obs",{type:H.prototype.parser,readUntil:"eof"}),W.prototype.fieldSpec=[],W.prototype.fieldSpec.push(["header",k.prototype.fieldSpec]),W.prototype.fieldSpec.push(["obs","array",H.prototype.fieldSpec,function(){return this.fields.array.length},null]);var Q=function(e,t){return p.call(this,e),this.messageType="MSG_IONO",this.fields=t||this.parser.parse(e.payload),this};(Q.prototype=Object.create(p.prototype)).messageType="MSG_IONO",Q.prototype.msg_type=144,Q.prototype.constructor=Q,Q.prototype.parser=(new o).endianess("little").nest("t_nmct",{type:c.prototype.parser}).doublele("a0").doublele("a1").doublele("a2").doublele("a3").doublele("b0").doublele("b1").doublele("b2").doublele("b3"),Q.prototype.fieldSpec=[],Q.prototype.fieldSpec.push(["t_nmct",c.prototype.fieldSpec]),Q.prototype.fieldSpec.push(["a0","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["a1","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["a2","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["a3","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["b0","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["b1","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["b2","writeDoubleLE",8]),Q.prototype.fieldSpec.push(["b3","writeDoubleLE",8]);var K=function(e,t){return p.call(this,e),this.messageType="MSG_SV_CONFIGURATION_GPS_DEP",this.fields=t||this.parser.parse(e.payload),this};(K.prototype=Object.create(p.prototype)).messageType="MSG_SV_CONFIGURATION_GPS_DEP",K.prototype.msg_type=145,K.prototype.constructor=K,K.prototype.parser=(new o).endianess("little").nest("t_nmct",{type:c.prototype.parser}).uint32("l2c_mask"),K.prototype.fieldSpec=[],K.prototype.fieldSpec.push(["t_nmct",c.prototype.fieldSpec]),K.prototype.fieldSpec.push(["l2c_mask","writeUInt32LE",4]);var X=function(e,t){return p.call(this,e),this.messageType="GnssCapb",this.fields=t||this.parser.parse(e.payload),this};(X.prototype=Object.create(p.prototype)).messageType="GnssCapb",X.prototype.constructor=X,X.prototype.parser=(new o).endianess("little").uint64("gps_active").uint64("gps_l2c").uint64("gps_l5").uint32("glo_active").uint32("glo_l2of").uint32("glo_l3").uint64("sbas_active").uint64("sbas_l5").uint64("bds_active").uint64("bds_d2nav").uint64("bds_b2").uint64("bds_b2a").uint32("qzss_active").uint64("gal_active").uint64("gal_e5"),X.prototype.fieldSpec=[],X.prototype.fieldSpec.push(["gps_active","writeUInt64LE",8]),X.prototype.fieldSpec.push(["gps_l2c","writeUInt64LE",8]),X.prototype.fieldSpec.push(["gps_l5","writeUInt64LE",8]),X.prototype.fieldSpec.push(["glo_active","writeUInt32LE",4]),X.prototype.fieldSpec.push(["glo_l2of","writeUInt32LE",4]),X.prototype.fieldSpec.push(["glo_l3","writeUInt32LE",4]),X.prototype.fieldSpec.push(["sbas_active","writeUInt64LE",8]),X.prototype.fieldSpec.push(["sbas_l5","writeUInt64LE",8]),X.prototype.fieldSpec.push(["bds_active","writeUInt64LE",8]),X.prototype.fieldSpec.push(["bds_d2nav","writeUInt64LE",8]),X.prototype.fieldSpec.push(["bds_b2","writeUInt64LE",8]),X.prototype.fieldSpec.push(["bds_b2a","writeUInt64LE",8]),X.prototype.fieldSpec.push(["qzss_active","writeUInt32LE",4]),X.prototype.fieldSpec.push(["gal_active","writeUInt64LE",8]),X.prototype.fieldSpec.push(["gal_e5","writeUInt64LE",8]);var J=function(e,t){return p.call(this,e),this.messageType="MSG_GNSS_CAPB",this.fields=t||this.parser.parse(e.payload),this};(J.prototype=Object.create(p.prototype)).messageType="MSG_GNSS_CAPB",J.prototype.msg_type=150,J.prototype.constructor=J,J.prototype.parser=(new o).endianess("little").nest("t_nmct",{type:c.prototype.parser}).nest("gc",{type:X.prototype.parser}),J.prototype.fieldSpec=[],J.prototype.fieldSpec.push(["t_nmct",c.prototype.fieldSpec]),J.prototype.fieldSpec.push(["gc",X.prototype.fieldSpec]);var $=function(e,t){return p.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_A",this.fields=t||this.parser.parse(e.payload),this};($.prototype=Object.create(p.prototype)).messageType="MSG_GROUP_DELAY_DEP_A",$.prototype.msg_type=146,$.prototype.constructor=$,$.prototype.parser=(new o).endianess("little").nest("t_op",{type:l.prototype.parser}).uint8("prn").uint8("valid").int16("tgd").int16("isc_l1ca").int16("isc_l2c"),$.prototype.fieldSpec=[],$.prototype.fieldSpec.push(["t_op",l.prototype.fieldSpec]),$.prototype.fieldSpec.push(["prn","writeUInt8",1]),$.prototype.fieldSpec.push(["valid","writeUInt8",1]),$.prototype.fieldSpec.push(["tgd","writeInt16LE",2]),$.prototype.fieldSpec.push(["isc_l1ca","writeInt16LE",2]),$.prototype.fieldSpec.push(["isc_l2c","writeInt16LE",2]);var Z=function(e,t){return p.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(Z.prototype=Object.create(p.prototype)).messageType="MSG_GROUP_DELAY_DEP_B",Z.prototype.msg_type=147,Z.prototype.constructor=Z,Z.prototype.parser=(new o).endianess("little").nest("t_op",{type:c.prototype.parser}).nest("sid",{type:n.prototype.parser}).uint8("valid").int16("tgd").int16("isc_l1ca").int16("isc_l2c"),Z.prototype.fieldSpec=[],Z.prototype.fieldSpec.push(["t_op",c.prototype.fieldSpec]),Z.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),Z.prototype.fieldSpec.push(["valid","writeUInt8",1]),Z.prototype.fieldSpec.push(["tgd","writeInt16LE",2]),Z.prototype.fieldSpec.push(["isc_l1ca","writeInt16LE",2]),Z.prototype.fieldSpec.push(["isc_l2c","writeInt16LE",2]);var ee=function(e,t){return p.call(this,e),this.messageType="MSG_GROUP_DELAY",this.fields=t||this.parser.parse(e.payload),this};(ee.prototype=Object.create(p.prototype)).messageType="MSG_GROUP_DELAY",ee.prototype.msg_type=148,ee.prototype.constructor=ee,ee.prototype.parser=(new o).endianess("little").nest("t_op",{type:c.prototype.parser}).nest("sid",{type:s.prototype.parser}).uint8("valid").int16("tgd").int16("isc_l1ca").int16("isc_l2c"),ee.prototype.fieldSpec=[],ee.prototype.fieldSpec.push(["t_op",c.prototype.fieldSpec]),ee.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),ee.prototype.fieldSpec.push(["valid","writeUInt8",1]),ee.prototype.fieldSpec.push(["tgd","writeInt16LE",2]),ee.prototype.fieldSpec.push(["isc_l1ca","writeInt16LE",2]),ee.prototype.fieldSpec.push(["isc_l2c","writeInt16LE",2]);var te=function(e,t){return p.call(this,e),this.messageType="AlmanacCommonContent",this.fields=t||this.parser.parse(e.payload),this};(te.prototype=Object.create(p.prototype)).messageType="AlmanacCommonContent",te.prototype.constructor=te,te.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).nest("toa",{type:c.prototype.parser}).doublele("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),te.prototype.fieldSpec=[],te.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),te.prototype.fieldSpec.push(["toa",c.prototype.fieldSpec]),te.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),te.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),te.prototype.fieldSpec.push(["valid","writeUInt8",1]),te.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);var re=function(e,t){return p.call(this,e),this.messageType="AlmanacCommonContentDep",this.fields=t||this.parser.parse(e.payload),this};(re.prototype=Object.create(p.prototype)).messageType="AlmanacCommonContentDep",re.prototype.constructor=re,re.prototype.parser=(new o).endianess("little").nest("sid",{type:n.prototype.parser}).nest("toa",{type:c.prototype.parser}).doublele("ura").uint32("fit_interval").uint8("valid").uint8("health_bits"),re.prototype.fieldSpec=[],re.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),re.prototype.fieldSpec.push(["toa",c.prototype.fieldSpec]),re.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),re.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),re.prototype.fieldSpec.push(["valid","writeUInt8",1]),re.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);var pe=function(e,t){return p.call(this,e),this.messageType="MSG_ALMANAC_GPS_DEP",this.fields=t||this.parser.parse(e.payload),this};(pe.prototype=Object.create(p.prototype)).messageType="MSG_ALMANAC_GPS_DEP",pe.prototype.msg_type=112,pe.prototype.constructor=pe,pe.prototype.parser=(new o).endianess("little").nest("common",{type:re.prototype.parser}).doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("af0").doublele("af1"),pe.prototype.fieldSpec=[],pe.prototype.fieldSpec.push(["common",re.prototype.fieldSpec]),pe.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["w","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["af1","writeDoubleLE",8]);var oe=function(e,t){return p.call(this,e),this.messageType="MSG_ALMANAC_GPS",this.fields=t||this.parser.parse(e.payload),this};(oe.prototype=Object.create(p.prototype)).messageType="MSG_ALMANAC_GPS",oe.prototype.msg_type=114,oe.prototype.constructor=oe,oe.prototype.parser=(new o).endianess("little").nest("common",{type:te.prototype.parser}).doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("af0").doublele("af1"),oe.prototype.fieldSpec=[],oe.prototype.fieldSpec.push(["common",te.prototype.fieldSpec]),oe.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["w","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),oe.prototype.fieldSpec.push(["af1","writeDoubleLE",8]);var ie=function(e,t){return p.call(this,e),this.messageType="MSG_ALMANAC_GLO_DEP",this.fields=t||this.parser.parse(e.payload),this};(ie.prototype=Object.create(p.prototype)).messageType="MSG_ALMANAC_GLO_DEP",ie.prototype.msg_type=113,ie.prototype.constructor=ie,ie.prototype.parser=(new o).endianess("little").nest("common",{type:re.prototype.parser}).doublele("lambda_na").doublele("t_lambda_na").doublele("i").doublele("t").doublele("t_dot").doublele("epsilon").doublele("omega"),ie.prototype.fieldSpec=[],ie.prototype.fieldSpec.push(["common",re.prototype.fieldSpec]),ie.prototype.fieldSpec.push(["lambda_na","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["t_lambda_na","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["i","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["t","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["t_dot","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["epsilon","writeDoubleLE",8]),ie.prototype.fieldSpec.push(["omega","writeDoubleLE",8]);var se=function(e,t){return p.call(this,e),this.messageType="MSG_ALMANAC_GLO",this.fields=t||this.parser.parse(e.payload),this};(se.prototype=Object.create(p.prototype)).messageType="MSG_ALMANAC_GLO",se.prototype.msg_type=115,se.prototype.constructor=se,se.prototype.parser=(new o).endianess("little").nest("common",{type:te.prototype.parser}).doublele("lambda_na").doublele("t_lambda_na").doublele("i").doublele("t").doublele("t_dot").doublele("epsilon").doublele("omega"),se.prototype.fieldSpec=[],se.prototype.fieldSpec.push(["common",te.prototype.fieldSpec]),se.prototype.fieldSpec.push(["lambda_na","writeDoubleLE",8]),se.prototype.fieldSpec.push(["t_lambda_na","writeDoubleLE",8]),se.prototype.fieldSpec.push(["i","writeDoubleLE",8]),se.prototype.fieldSpec.push(["t","writeDoubleLE",8]),se.prototype.fieldSpec.push(["t_dot","writeDoubleLE",8]),se.prototype.fieldSpec.push(["epsilon","writeDoubleLE",8]),se.prototype.fieldSpec.push(["omega","writeDoubleLE",8]);var ne=function(e,t){return p.call(this,e),this.messageType="MSG_GLO_BIASES",this.fields=t||this.parser.parse(e.payload),this};(ne.prototype=Object.create(p.prototype)).messageType="MSG_GLO_BIASES",ne.prototype.msg_type=117,ne.prototype.constructor=ne,ne.prototype.parser=(new o).endianess("little").uint8("mask").int16("l1ca_bias").int16("l1p_bias").int16("l2ca_bias").int16("l2p_bias"),ne.prototype.fieldSpec=[],ne.prototype.fieldSpec.push(["mask","writeUInt8",1]),ne.prototype.fieldSpec.push(["l1ca_bias","writeInt16LE",2]),ne.prototype.fieldSpec.push(["l1p_bias","writeInt16LE",2]),ne.prototype.fieldSpec.push(["l2ca_bias","writeInt16LE",2]),ne.prototype.fieldSpec.push(["l2p_bias","writeInt16LE",2]);var ae=function(e,t){return p.call(this,e),this.messageType="SvAzEl",this.fields=t||this.parser.parse(e.payload),this};(ae.prototype=Object.create(p.prototype)).messageType="SvAzEl",ae.prototype.constructor=ae,ae.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).uint8("az").int8("el"),ae.prototype.fieldSpec=[],ae.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),ae.prototype.fieldSpec.push(["az","writeUInt8",1]),ae.prototype.fieldSpec.push(["el","writeInt8",1]);var le=function(e,t){return p.call(this,e),this.messageType="MSG_SV_AZ_EL",this.fields=t||this.parser.parse(e.payload),this};(le.prototype=Object.create(p.prototype)).messageType="MSG_SV_AZ_EL",le.prototype.msg_type=151,le.prototype.constructor=le,le.prototype.parser=(new o).endianess("little").array("azel",{type:ae.prototype.parser,readUntil:"eof"}),le.prototype.fieldSpec=[],le.prototype.fieldSpec.push(["azel","array",ae.prototype.fieldSpec,function(){return this.fields.array.length},null]);var ce=function(e,t){return p.call(this,e),this.messageType="MSG_OSR",this.fields=t||this.parser.parse(e.payload),this};(ce.prototype=Object.create(p.prototype)).messageType="MSG_OSR",ce.prototype.msg_type=1600,ce.prototype.constructor=ce,ce.prototype.parser=(new o).endianess("little").nest("header",{type:u.prototype.parser}).array("obs",{type:f.prototype.parser,readUntil:"eof"}),ce.prototype.fieldSpec=[],ce.prototype.fieldSpec.push(["header",u.prototype.fieldSpec]),ce.prototype.fieldSpec.push(["obs","array",f.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={ObservationHeader:u,Doppler:y,PackedObsContent:h,PackedOsrContent:f,74:d,MsgObs:d,68:_,MsgBasePosLlh:_,72:S,MsgBasePosEcef:S,EphemerisCommonContent:g,EphemerisCommonContentDepB:w,EphemerisCommonContentDepA:E,129:m,MsgEphemerisGpsDepE:m,134:b,MsgEphemerisGpsDepF:b,138:v,MsgEphemerisGps:v,142:I,MsgEphemerisQzss:I,137:L,MsgEphemerisBds:L,149:T,MsgEphemerisGalDepA:T,141:U,MsgEphemerisGal:U,130:M,MsgEphemerisSbasDepA:M,131:D,MsgEphemerisGloDepA:D,132:O,MsgEphemerisSbasDepB:O,140:G,MsgEphemerisSbas:G,133:A,MsgEphemerisGloDepB:A,135:C,MsgEphemerisGloDepC:C,136:R,MsgEphemerisGloDepD:R,139:P,MsgEphemerisGlo:P,128:N,MsgEphemerisDepD:N,26:j,MsgEphemerisDepA:j,70:x,MsgEphemerisDepB:x,71:F,MsgEphemerisDepC:F,ObservationHeaderDep:k,CarrierPhaseDepA:B,PackedObsContentDepA:q,PackedObsContentDepB:z,PackedObsContentDepC:H,69:V,MsgObsDepA:V,67:Y,MsgObsDepB:Y,73:W,MsgObsDepC:W,144:Q,MsgIono:Q,145:K,MsgSvConfigurationGpsDep:K,GnssCapb:X,150:J,MsgGnssCapb:J,146:$,MsgGroupDelayDepA:$,147:Z,MsgGroupDelayDepB:Z,148:ee,MsgGroupDelay:ee,AlmanacCommonContent:te,AlmanacCommonContentDep:re,112:pe,MsgAlmanacGpsDep:pe,114:oe,MsgAlmanacGps:oe,113:ie,MsgAlmanacGloDep:ie,115:se,MsgAlmanacGlo:se,117:ne,MsgGloBiases:ne,SvAzEl:ae,151:le,MsgSvAzEl:le,1600:ce,MsgOsr:ce}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_BASELINE_HEADING",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_BASELINE_HEADING",i.prototype.msg_type=527,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("tow").uint32("heading").uint8("n_sats").uint8("flags"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["heading","writeUInt32LE",4]),i.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_ORIENT_QUAT",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_ORIENT_QUAT",s.prototype.msg_type=544,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint32("tow").int32("w").int32("x").int32("y").int32("z").floatle("w_accuracy").floatle("x_accuracy").floatle("y_accuracy").floatle("z_accuracy").uint8("flags"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["w","writeInt32LE",4]),s.prototype.fieldSpec.push(["x","writeInt32LE",4]),s.prototype.fieldSpec.push(["y","writeInt32LE",4]),s.prototype.fieldSpec.push(["z","writeInt32LE",4]),s.prototype.fieldSpec.push(["w_accuracy","writeFloatLE",4]),s.prototype.fieldSpec.push(["x_accuracy","writeFloatLE",4]),s.prototype.fieldSpec.push(["y_accuracy","writeFloatLE",4]),s.prototype.fieldSpec.push(["z_accuracy","writeFloatLE",4]),s.prototype.fieldSpec.push(["flags","writeUInt8",1]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_ORIENT_EULER",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_ORIENT_EULER",n.prototype.msg_type=545,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint32("tow").int32("roll").int32("pitch").int32("yaw").floatle("roll_accuracy").floatle("pitch_accuracy").floatle("yaw_accuracy").uint8("flags"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),n.prototype.fieldSpec.push(["roll","writeInt32LE",4]),n.prototype.fieldSpec.push(["pitch","writeInt32LE",4]),n.prototype.fieldSpec.push(["yaw","writeInt32LE",4]),n.prototype.fieldSpec.push(["roll_accuracy","writeFloatLE",4]),n.prototype.fieldSpec.push(["pitch_accuracy","writeFloatLE",4]),n.prototype.fieldSpec.push(["yaw_accuracy","writeFloatLE",4]),n.prototype.fieldSpec.push(["flags","writeUInt8",1]);var a=function(e,t){return p.call(this,e),this.messageType="MSG_ANGULAR_RATE",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="MSG_ANGULAR_RATE",a.prototype.msg_type=546,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint32("tow").int32("x").int32("y").int32("z").uint8("flags"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),a.prototype.fieldSpec.push(["x","writeInt32LE",4]),a.prototype.fieldSpec.push(["y","writeInt32LE",4]),a.prototype.fieldSpec.push(["z","writeInt32LE",4]),a.prototype.fieldSpec.push(["flags","writeUInt8",1]),e.exports={527:i,MsgBaselineHeading:i,544:s,MsgOrientQuat:s,545:n,MsgOrientEuler:n,546:a,MsgAngularRate:a}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,r(0).CarrierPhase,r(0).GnssSignal),s=r(0).GnssSignalDep,n=r(0).GPSTime,a=r(0).GPSTimeDep,l=(r(0).GPSTimeSec,r(0).SvId,function(e,t){return p.call(this,e),this.messageType="MSG_ALMANAC",this.fields=t||this.parser.parse(e.payload),this});(l.prototype=Object.create(p.prototype)).messageType="MSG_ALMANAC",l.prototype.msg_type=105,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little"),l.prototype.fieldSpec=[];var c=function(e,t){return p.call(this,e),this.messageType="MSG_SET_TIME",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="MSG_SET_TIME",c.prototype.msg_type=104,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little"),c.prototype.fieldSpec=[];var u=function(e,t){return p.call(this,e),this.messageType="MSG_RESET",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="MSG_RESET",u.prototype.msg_type=182,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint32("flags"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);var y=function(e,t){return p.call(this,e),this.messageType="MSG_RESET_DEP",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="MSG_RESET_DEP",y.prototype.msg_type=178,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little"),y.prototype.fieldSpec=[];var h=function(e,t){return p.call(this,e),this.messageType="MSG_CW_RESULTS",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_CW_RESULTS",h.prototype.msg_type=192,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little"),h.prototype.fieldSpec=[];var f=function(e,t){return p.call(this,e),this.messageType="MSG_CW_START",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="MSG_CW_START",f.prototype.msg_type=193,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little"),f.prototype.fieldSpec=[];var d=function(e,t){return p.call(this,e),this.messageType="MSG_RESET_FILTERS",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(p.prototype)).messageType="MSG_RESET_FILTERS",d.prototype.msg_type=34,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint8("filter"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["filter","writeUInt8",1]);var _=function(e,t){return p.call(this,e),this.messageType="MSG_INIT_BASE_DEP",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(p.prototype)).messageType="MSG_INIT_BASE_DEP",_.prototype.msg_type=35,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little"),_.prototype.fieldSpec=[];var S=function(e,t){return p.call(this,e),this.messageType="MSG_THREAD_STATE",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(p.prototype)).messageType="MSG_THREAD_STATE",S.prototype.msg_type=23,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").string("name",{length:20}).uint16("cpu").uint32("stack_free"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["name","string",20]),S.prototype.fieldSpec.push(["cpu","writeUInt16LE",2]),S.prototype.fieldSpec.push(["stack_free","writeUInt32LE",4]);var g=function(e,t){return p.call(this,e),this.messageType="UARTChannel",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(p.prototype)).messageType="UARTChannel",g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").floatle("tx_throughput").floatle("rx_throughput").uint16("crc_error_count").uint16("io_error_count").uint8("tx_buffer_level").uint8("rx_buffer_level"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["tx_throughput","writeFloatLE",4]),g.prototype.fieldSpec.push(["rx_throughput","writeFloatLE",4]),g.prototype.fieldSpec.push(["crc_error_count","writeUInt16LE",2]),g.prototype.fieldSpec.push(["io_error_count","writeUInt16LE",2]),g.prototype.fieldSpec.push(["tx_buffer_level","writeUInt8",1]),g.prototype.fieldSpec.push(["rx_buffer_level","writeUInt8",1]);var w=function(e,t){return p.call(this,e),this.messageType="Period",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(p.prototype)).messageType="Period",w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").int32("avg").int32("pmin").int32("pmax").int32("current"),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["avg","writeInt32LE",4]),w.prototype.fieldSpec.push(["pmin","writeInt32LE",4]),w.prototype.fieldSpec.push(["pmax","writeInt32LE",4]),w.prototype.fieldSpec.push(["current","writeInt32LE",4]);var E=function(e,t){return p.call(this,e),this.messageType="Latency",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(p.prototype)).messageType="Latency",E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").int32("avg").int32("lmin").int32("lmax").int32("current"),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["avg","writeInt32LE",4]),E.prototype.fieldSpec.push(["lmin","writeInt32LE",4]),E.prototype.fieldSpec.push(["lmax","writeInt32LE",4]),E.prototype.fieldSpec.push(["current","writeInt32LE",4]);var m=function(e,t){return p.call(this,e),this.messageType="MSG_UART_STATE",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(p.prototype)).messageType="MSG_UART_STATE",m.prototype.msg_type=29,m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").nest("uart_a",{type:g.prototype.parser}).nest("uart_b",{type:g.prototype.parser}).nest("uart_ftdi",{type:g.prototype.parser}).nest("latency",{type:E.prototype.parser}).nest("obs_period",{type:w.prototype.parser}),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["uart_a",g.prototype.fieldSpec]),m.prototype.fieldSpec.push(["uart_b",g.prototype.fieldSpec]),m.prototype.fieldSpec.push(["uart_ftdi",g.prototype.fieldSpec]),m.prototype.fieldSpec.push(["latency",E.prototype.fieldSpec]),m.prototype.fieldSpec.push(["obs_period",w.prototype.fieldSpec]);var b=function(e,t){return p.call(this,e),this.messageType="MSG_UART_STATE_DEPA",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(p.prototype)).messageType="MSG_UART_STATE_DEPA",b.prototype.msg_type=24,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").nest("uart_a",{type:g.prototype.parser}).nest("uart_b",{type:g.prototype.parser}).nest("uart_ftdi",{type:g.prototype.parser}).nest("latency",{type:E.prototype.parser}),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["uart_a",g.prototype.fieldSpec]),b.prototype.fieldSpec.push(["uart_b",g.prototype.fieldSpec]),b.prototype.fieldSpec.push(["uart_ftdi",g.prototype.fieldSpec]),b.prototype.fieldSpec.push(["latency",E.prototype.fieldSpec]);var v=function(e,t){return p.call(this,e),this.messageType="MSG_IAR_STATE",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(p.prototype)).messageType="MSG_IAR_STATE",v.prototype.msg_type=25,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").uint32("num_hyps"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["num_hyps","writeUInt32LE",4]);var I=function(e,t){return p.call(this,e),this.messageType="MSG_MASK_SATELLITE",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(p.prototype)).messageType="MSG_MASK_SATELLITE",I.prototype.msg_type=43,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").uint8("mask").nest("sid",{type:i.prototype.parser}),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["mask","writeUInt8",1]),I.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]);var L=function(e,t){return p.call(this,e),this.messageType="MSG_MASK_SATELLITE_DEP",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(p.prototype)).messageType="MSG_MASK_SATELLITE_DEP",L.prototype.msg_type=27,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").uint8("mask").nest("sid",{type:s.prototype.parser}),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["mask","writeUInt8",1]),L.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]);var T=function(e,t){return p.call(this,e),this.messageType="MSG_DEVICE_MONITOR",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(p.prototype)).messageType="MSG_DEVICE_MONITOR",T.prototype.msg_type=181,T.prototype.constructor=T,T.prototype.parser=(new o).endianess("little").int16("dev_vin").int16("cpu_vint").int16("cpu_vaux").int16("cpu_temperature").int16("fe_temperature"),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["dev_vin","writeInt16LE",2]),T.prototype.fieldSpec.push(["cpu_vint","writeInt16LE",2]),T.prototype.fieldSpec.push(["cpu_vaux","writeInt16LE",2]),T.prototype.fieldSpec.push(["cpu_temperature","writeInt16LE",2]),T.prototype.fieldSpec.push(["fe_temperature","writeInt16LE",2]);var U=function(e,t){return p.call(this,e),this.messageType="MSG_COMMAND_REQ",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(p.prototype)).messageType="MSG_COMMAND_REQ",U.prototype.msg_type=184,U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").uint32("sequence").string("command",{greedy:!0}),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),U.prototype.fieldSpec.push(["command","string",null]);var M=function(e,t){return p.call(this,e),this.messageType="MSG_COMMAND_RESP",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(p.prototype)).messageType="MSG_COMMAND_RESP",M.prototype.msg_type=185,M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").uint32("sequence").int32("code"),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),M.prototype.fieldSpec.push(["code","writeInt32LE",4]);var D=function(e,t){return p.call(this,e),this.messageType="MSG_COMMAND_OUTPUT",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(p.prototype)).messageType="MSG_COMMAND_OUTPUT",D.prototype.msg_type=188,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").uint32("sequence").string("line",{greedy:!0}),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),D.prototype.fieldSpec.push(["line","string",null]);var O=function(e,t){return p.call(this,e),this.messageType="MSG_NETWORK_STATE_REQ",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(p.prototype)).messageType="MSG_NETWORK_STATE_REQ",O.prototype.msg_type=186,O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little"),O.prototype.fieldSpec=[];var G=function(e,t){return p.call(this,e),this.messageType="MSG_NETWORK_STATE_RESP",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(p.prototype)).messageType="MSG_NETWORK_STATE_RESP",G.prototype.msg_type=187,G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").array("ipv4_address",{length:4,type:"uint8"}).uint8("ipv4_mask_size").array("ipv6_address",{length:16,type:"uint8"}).uint8("ipv6_mask_size").uint32("rx_bytes").uint32("tx_bytes").string("interface_name",{length:16}).uint32("flags"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["ipv4_address","array","writeUInt8",function(){return 1},4]),G.prototype.fieldSpec.push(["ipv4_mask_size","writeUInt8",1]),G.prototype.fieldSpec.push(["ipv6_address","array","writeUInt8",function(){return 1},16]),G.prototype.fieldSpec.push(["ipv6_mask_size","writeUInt8",1]),G.prototype.fieldSpec.push(["rx_bytes","writeUInt32LE",4]),G.prototype.fieldSpec.push(["tx_bytes","writeUInt32LE",4]),G.prototype.fieldSpec.push(["interface_name","string",16]),G.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);var A=function(e,t){return p.call(this,e),this.messageType="NetworkUsage",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(p.prototype)).messageType="NetworkUsage",A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").uint64("duration").uint64("total_bytes").uint32("rx_bytes").uint32("tx_bytes").string("interface_name",{length:16}),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["duration","writeUInt64LE",8]),A.prototype.fieldSpec.push(["total_bytes","writeUInt64LE",8]),A.prototype.fieldSpec.push(["rx_bytes","writeUInt32LE",4]),A.prototype.fieldSpec.push(["tx_bytes","writeUInt32LE",4]),A.prototype.fieldSpec.push(["interface_name","string",16]);var C=function(e,t){return p.call(this,e),this.messageType="MSG_NETWORK_BANDWIDTH_USAGE",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(p.prototype)).messageType="MSG_NETWORK_BANDWIDTH_USAGE",C.prototype.msg_type=189,C.prototype.constructor=C,C.prototype.parser=(new o).endianess("little").array("interfaces",{type:A.prototype.parser,readUntil:"eof"}),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["interfaces","array",A.prototype.fieldSpec,function(){return this.fields.array.length},null]);var R=function(e,t){return p.call(this,e),this.messageType="MSG_CELL_MODEM_STATUS",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(p.prototype)).messageType="MSG_CELL_MODEM_STATUS",R.prototype.msg_type=190,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").int8("signal_strength").floatle("signal_error_rate").array("reserved",{type:"uint8",readUntil:"eof"}),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["signal_strength","writeInt8",1]),R.prototype.fieldSpec.push(["signal_error_rate","writeFloatLE",4]),R.prototype.fieldSpec.push(["reserved","array","writeUInt8",function(){return 1},null]);var P=function(e,t){return p.call(this,e),this.messageType="MSG_SPECAN_DEP",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(p.prototype)).messageType="MSG_SPECAN_DEP",P.prototype.msg_type=80,P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").uint16("channel_tag").nest("t",{type:a.prototype.parser}).floatle("freq_ref").floatle("freq_step").floatle("amplitude_ref").floatle("amplitude_unit").array("amplitude_value",{type:"uint8",readUntil:"eof"}),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["channel_tag","writeUInt16LE",2]),P.prototype.fieldSpec.push(["t",a.prototype.fieldSpec]),P.prototype.fieldSpec.push(["freq_ref","writeFloatLE",4]),P.prototype.fieldSpec.push(["freq_step","writeFloatLE",4]),P.prototype.fieldSpec.push(["amplitude_ref","writeFloatLE",4]),P.prototype.fieldSpec.push(["amplitude_unit","writeFloatLE",4]),P.prototype.fieldSpec.push(["amplitude_value","array","writeUInt8",function(){return 1},null]);var N=function(e,t){return p.call(this,e),this.messageType="MSG_SPECAN",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(p.prototype)).messageType="MSG_SPECAN",N.prototype.msg_type=81,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").uint16("channel_tag").nest("t",{type:n.prototype.parser}).floatle("freq_ref").floatle("freq_step").floatle("amplitude_ref").floatle("amplitude_unit").array("amplitude_value",{type:"uint8",readUntil:"eof"}),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["channel_tag","writeUInt16LE",2]),N.prototype.fieldSpec.push(["t",n.prototype.fieldSpec]),N.prototype.fieldSpec.push(["freq_ref","writeFloatLE",4]),N.prototype.fieldSpec.push(["freq_step","writeFloatLE",4]),N.prototype.fieldSpec.push(["amplitude_ref","writeFloatLE",4]),N.prototype.fieldSpec.push(["amplitude_unit","writeFloatLE",4]),N.prototype.fieldSpec.push(["amplitude_value","array","writeUInt8",function(){return 1},null]);var j=function(e,t){return p.call(this,e),this.messageType="MSG_FRONT_END_GAIN",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(p.prototype)).messageType="MSG_FRONT_END_GAIN",j.prototype.msg_type=191,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").array("rf_gain",{length:8,type:"int8"}).array("if_gain",{length:8,type:"int8"}),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["rf_gain","array","writeInt8",function(){return 1},8]),j.prototype.fieldSpec.push(["if_gain","array","writeInt8",function(){return 1},8]),e.exports={105:l,MsgAlmanac:l,104:c,MsgSetTime:c,182:u,MsgReset:u,178:y,MsgResetDep:y,192:h,MsgCwResults:h,193:f,MsgCwStart:f,34:d,MsgResetFilters:d,35:_,MsgInitBaseDep:_,23:S,MsgThreadState:S,UARTChannel:g,Period:w,Latency:E,29:m,MsgUartState:m,24:b,MsgUartStateDepa:b,25:v,MsgIarState:v,43:I,MsgMaskSatellite:I,27:L,MsgMaskSatelliteDep:L,181:T,MsgDeviceMonitor:T,184:U,MsgCommandReq:U,185:M,MsgCommandResp:M,188:D,MsgCommandOutput:D,186:O,MsgNetworkStateReq:O,187:G,MsgNetworkStateResp:G,NetworkUsage:A,189:C,MsgNetworkBandwidthUsage:C,190:R,MsgCellModemStatus:R,80:P,MsgSpecanDep:P,81:N,MsgSpecan:N,191:j,MsgFrontEndGain:j}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,r(0).CarrierPhase,r(0).GnssSignal),s=(r(0).GnssSignalDep,r(0).GPSTime,r(0).GPSTimeDep,r(0).GPSTimeSec,r(0).SvId,function(e,t){return p.call(this,e),this.messageType="MSG_SBAS_RAW",this.fields=t||this.parser.parse(e.payload),this});(s.prototype=Object.create(p.prototype)).messageType="MSG_SBAS_RAW",s.prototype.msg_type=30583,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").nest("sid",{type:i.prototype.parser}).uint32("tow").uint8("message_type").array("data",{length:27,type:"uint8"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),s.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["message_type","writeUInt8",1]),s.prototype.fieldSpec.push(["data","array","writeUInt8",function(){return 1},27]),e.exports={30583:s,MsgSbasRaw:s}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_SAVE",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_SAVE",i.prototype.msg_type=161,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little"),i.prototype.fieldSpec=[];var s=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_WRITE",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_WRITE",s.prototype.msg_type=160,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["setting","string",null]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_WRITE_RESP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_WRITE_RESP",n.prototype.msg_type=175,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint8("status").string("setting",{greedy:!0}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["status","writeUInt8",1]),n.prototype.fieldSpec.push(["setting","string",null]);var a=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_READ_REQ",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_READ_REQ",a.prototype.msg_type=164,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["setting","string",null]);var l=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_READ_RESP",l.prototype.msg_type=165,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["setting","string",null]);var c=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_REQ",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_READ_BY_INDEX_REQ",c.prototype.msg_type=162,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint16("index"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["index","writeUInt16LE",2]);var u=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_RESP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_READ_BY_INDEX_RESP",u.prototype.msg_type=167,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint16("index").string("setting",{greedy:!0}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["index","writeUInt16LE",2]),u.prototype.fieldSpec.push(["setting","string",null]);var y=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_DONE",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_READ_BY_INDEX_DONE",y.prototype.msg_type=166,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little"),y.prototype.fieldSpec=[];var h=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_REGISTER",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_REGISTER",h.prototype.msg_type=174,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").string("setting",{greedy:!0}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["setting","string",null]);var f=function(e,t){return p.call(this,e),this.messageType="MSG_SETTINGS_REGISTER_RESP",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="MSG_SETTINGS_REGISTER_RESP",f.prototype.msg_type=431,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("status").string("setting",{greedy:!0}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["status","writeUInt8",1]),f.prototype.fieldSpec.push(["setting","string",null]),e.exports={161:i,MsgSettingsSave:i,160:s,MsgSettingsWrite:s,175:n,MsgSettingsWriteResp:n,164:a,MsgSettingsReadReq:a,165:l,MsgSettingsReadResp:l,162:c,MsgSettingsReadByIndexReq:c,167:u,MsgSettingsReadByIndexResp:u,166:y,MsgSettingsReadByIndexDone:y,174:h,MsgSettingsRegister:h,431:f,MsgSettingsRegisterResp:f}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="SolutionInputType",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="SolutionInputType",i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("sensor_type").uint8("flags"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["sensor_type","writeUInt8",1]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_SOLN_META_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_SOLN_META_DEP_A",s.prototype.msg_type=65295,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint16("pdop").uint16("hdop").uint16("vdop").uint8("n_sats").uint16("age_corrections").uint8("alignment_status").uint32("last_used_gnss_pos_tow").uint32("last_used_gnss_vel_tow").array("sol_in",{type:i.prototype.parser,readUntil:"eof"}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),s.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),s.prototype.fieldSpec.push(["vdop","writeUInt16LE",2]),s.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),s.prototype.fieldSpec.push(["age_corrections","writeUInt16LE",2]),s.prototype.fieldSpec.push(["alignment_status","writeUInt8",1]),s.prototype.fieldSpec.push(["last_used_gnss_pos_tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["last_used_gnss_vel_tow","writeUInt32LE",4]),s.prototype.fieldSpec.push(["sol_in","array",i.prototype.fieldSpec,function(){return this.fields.array.length},null]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_SOLN_META",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_SOLN_META",n.prototype.msg_type=65294,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint32("tow").uint16("pdop").uint16("hdop").uint16("vdop").uint16("age_corrections").uint32("age_gnss").array("sol_in",{type:i.prototype.parser,readUntil:"eof"}),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),n.prototype.fieldSpec.push(["pdop","writeUInt16LE",2]),n.prototype.fieldSpec.push(["hdop","writeUInt16LE",2]),n.prototype.fieldSpec.push(["vdop","writeUInt16LE",2]),n.prototype.fieldSpec.push(["age_corrections","writeUInt16LE",2]),n.prototype.fieldSpec.push(["age_gnss","writeUInt32LE",4]),n.prototype.fieldSpec.push(["sol_in","array",i.prototype.fieldSpec,function(){return this.fields.array.length},null]);var a=function(e,t){return p.call(this,e),this.messageType="GNSSInputType",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="GNSSInputType",a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("flags"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["flags","writeUInt8",1]);var l=function(e,t){return p.call(this,e),this.messageType="IMUInputType",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="IMUInputType",l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("flags"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["flags","writeUInt8",1]);var c=function(e,t){return p.call(this,e),this.messageType="OdoInputType",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="OdoInputType",c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint8("flags"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["flags","writeUInt8",1]),e.exports={SolutionInputType:i,65295:s,MsgSolnMetaDepA:s,65294:n,MsgSolnMeta:n,GNSSInputType:a,IMUInputType:l,OdoInputType:c}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,r(0).CarrierPhase,r(0).GnssSignal),s=(r(0).GnssSignalDep,r(0).GPSTime,r(0).GPSTimeDep,r(0).GPSTimeSec),n=r(0).SvId,a=function(e,t){return p.call(this,e),this.messageType="CodeBiasesContent",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="CodeBiasesContent",a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint8("code").int16("value"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["code","writeUInt8",1]),a.prototype.fieldSpec.push(["value","writeInt16LE",2]);var l=function(e,t){return p.call(this,e),this.messageType="PhaseBiasesContent",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="PhaseBiasesContent",l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint8("code").uint8("integer_indicator").uint8("widelane_integer_indicator").uint8("discontinuity_counter").int32("bias"),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["code","writeUInt8",1]),l.prototype.fieldSpec.push(["integer_indicator","writeUInt8",1]),l.prototype.fieldSpec.push(["widelane_integer_indicator","writeUInt8",1]),l.prototype.fieldSpec.push(["discontinuity_counter","writeUInt8",1]),l.prototype.fieldSpec.push(["bias","writeInt32LE",4]);var c=function(e,t){return p.call(this,e),this.messageType="STECHeader",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="STECHeader",c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint16("tile_set_id").uint16("tile_id").nest("time",{type:s.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("update_interval").uint8("iod_atmo"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),c.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),c.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),c.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),c.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),c.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),c.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]);var u=function(e,t){return p.call(this,e),this.messageType="GriddedCorrectionHeader",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="GriddedCorrectionHeader",u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint16("tile_set_id").uint16("tile_id").nest("time",{type:s.prototype.parser}).uint16("num_msgs").uint16("seq_num").uint8("update_interval").uint8("iod_atmo").uint8("tropo_quality_indicator"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),u.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),u.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),u.prototype.fieldSpec.push(["num_msgs","writeUInt16LE",2]),u.prototype.fieldSpec.push(["seq_num","writeUInt16LE",2]),u.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),u.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]),u.prototype.fieldSpec.push(["tropo_quality_indicator","writeUInt8",1]);var y=function(e,t){return p.call(this,e),this.messageType="STECSatElement",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="STECSatElement",y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").nest("sv_id",{type:n.prototype.parser}).uint8("stec_quality_indicator").array("stec_coeff",{length:4,type:"int16le"}),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["sv_id",n.prototype.fieldSpec]),y.prototype.fieldSpec.push(["stec_quality_indicator","writeUInt8",1]),y.prototype.fieldSpec.push(["stec_coeff","array","writeInt16LE",function(){return 2},4]);var h=function(e,t){return p.call(this,e),this.messageType="TroposphericDelayCorrectionNoStd",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="TroposphericDelayCorrectionNoStd",h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").int16("hydro").int8("wet"),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["hydro","writeInt16LE",2]),h.prototype.fieldSpec.push(["wet","writeInt8",1]);var f=function(e,t){return p.call(this,e),this.messageType="TroposphericDelayCorrection",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="TroposphericDelayCorrection",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").int16("hydro").int8("wet").uint8("stddev"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["hydro","writeInt16LE",2]),f.prototype.fieldSpec.push(["wet","writeInt8",1]),f.prototype.fieldSpec.push(["stddev","writeUInt8",1]);var d=function(e,t){return p.call(this,e),this.messageType="STECResidualNoStd",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(p.prototype)).messageType="STECResidualNoStd",d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").nest("sv_id",{type:n.prototype.parser}).int16("residual"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["sv_id",n.prototype.fieldSpec]),d.prototype.fieldSpec.push(["residual","writeInt16LE",2]);var _=function(e,t){return p.call(this,e),this.messageType="STECResidual",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(p.prototype)).messageType="STECResidual",_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").nest("sv_id",{type:n.prototype.parser}).int16("residual").uint8("stddev"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["sv_id",n.prototype.fieldSpec]),_.prototype.fieldSpec.push(["residual","writeInt16LE",2]),_.prototype.fieldSpec.push(["stddev","writeUInt8",1]);var S=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(p.prototype)).messageType="MSG_SSR_ORBIT_CLOCK",S.prototype.msg_type=1501,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).nest("sid",{type:i.prototype.parser}).uint8("update_interval").uint8("iod_ssr").uint32("iod").int32("radial").int32("along").int32("cross").int32("dot_radial").int32("dot_along").int32("dot_cross").int32("c0").int32("c1").int32("c2"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),S.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),S.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),S.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),S.prototype.fieldSpec.push(["iod","writeUInt32LE",4]),S.prototype.fieldSpec.push(["radial","writeInt32LE",4]),S.prototype.fieldSpec.push(["along","writeInt32LE",4]),S.prototype.fieldSpec.push(["cross","writeInt32LE",4]),S.prototype.fieldSpec.push(["dot_radial","writeInt32LE",4]),S.prototype.fieldSpec.push(["dot_along","writeInt32LE",4]),S.prototype.fieldSpec.push(["dot_cross","writeInt32LE",4]),S.prototype.fieldSpec.push(["c0","writeInt32LE",4]),S.prototype.fieldSpec.push(["c1","writeInt32LE",4]),S.prototype.fieldSpec.push(["c2","writeInt32LE",4]);var g=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_CODE_BIASES",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(p.prototype)).messageType="MSG_SSR_CODE_BIASES",g.prototype.msg_type=1505,g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).nest("sid",{type:i.prototype.parser}).uint8("update_interval").uint8("iod_ssr").array("biases",{type:a.prototype.parser,readUntil:"eof"}),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),g.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),g.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),g.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),g.prototype.fieldSpec.push(["biases","array",a.prototype.fieldSpec,function(){return this.fields.array.length},null]);var w=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_PHASE_BIASES",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(p.prototype)).messageType="MSG_SSR_PHASE_BIASES",w.prototype.msg_type=1510,w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).nest("sid",{type:i.prototype.parser}).uint8("update_interval").uint8("iod_ssr").uint8("dispersive_bias").uint8("mw_consistency").uint16("yaw").int8("yaw_rate").array("biases",{type:l.prototype.parser,readUntil:"eof"}),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),w.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),w.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),w.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),w.prototype.fieldSpec.push(["dispersive_bias","writeUInt8",1]),w.prototype.fieldSpec.push(["mw_consistency","writeUInt8",1]),w.prototype.fieldSpec.push(["yaw","writeUInt16LE",2]),w.prototype.fieldSpec.push(["yaw_rate","writeInt8",1]),w.prototype.fieldSpec.push(["biases","array",l.prototype.fieldSpec,function(){return this.fields.array.length},null]);var E=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_STEC_CORRECTION_DEP",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(p.prototype)).messageType="MSG_SSR_STEC_CORRECTION_DEP",E.prototype.msg_type=1531,E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").nest("header",{type:c.prototype.parser}).array("stec_sat_list",{type:y.prototype.parser,readUntil:"eof"}),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["header",c.prototype.fieldSpec]),E.prototype.fieldSpec.push(["stec_sat_list","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);var m=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_STEC_CORRECTION",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(p.prototype)).messageType="MSG_SSR_STEC_CORRECTION",m.prototype.msg_type=1533,m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").array("stub",{type:"uint8",readUntil:"eof"}),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["stub","array","writeUInt8",function(){return 1},null]);var b=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(p.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION",b.prototype.msg_type=1532,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").nest("header",{type:u.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:f.prototype.parser}).array("stec_residuals",{type:_.prototype.parser,readUntil:"eof"}),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["header",u.prototype.fieldSpec]),b.prototype.fieldSpec.push(["index","writeUInt16LE",2]),b.prototype.fieldSpec.push(["tropo_delay_correction",f.prototype.fieldSpec]),b.prototype.fieldSpec.push(["stec_residuals","array",_.prototype.fieldSpec,function(){return this.fields.array.length},null]);var v=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION_BOUNDS",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(p.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_BOUNDS",v.prototype.msg_type=1534,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").array("stub",{type:"uint8",readUntil:"eof"}),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["stub","array","writeUInt8",function(){return 1},null]);var I=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_TILE_DEFINITION_DEP",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(p.prototype)).messageType="MSG_SSR_TILE_DEFINITION_DEP",I.prototype.msg_type=1526,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").uint16("tile_set_id").uint16("tile_id").int16("corner_nw_lat").int16("corner_nw_lon").uint16("spacing_lat").uint16("spacing_lon").uint16("rows").uint16("cols").uint64("bitmask"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),I.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),I.prototype.fieldSpec.push(["corner_nw_lat","writeInt16LE",2]),I.prototype.fieldSpec.push(["corner_nw_lon","writeInt16LE",2]),I.prototype.fieldSpec.push(["spacing_lat","writeUInt16LE",2]),I.prototype.fieldSpec.push(["spacing_lon","writeUInt16LE",2]),I.prototype.fieldSpec.push(["rows","writeUInt16LE",2]),I.prototype.fieldSpec.push(["cols","writeUInt16LE",2]),I.prototype.fieldSpec.push(["bitmask","writeUInt64LE",8]);var L=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_TILE_DEFINITION",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(p.prototype)).messageType="MSG_SSR_TILE_DEFINITION",L.prototype.msg_type=1527,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").array("stub",{type:"uint8",readUntil:"eof"}),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["stub","array","writeUInt8",function(){return 1},null]);var T=function(e,t){return p.call(this,e),this.messageType="SatelliteAPC",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(p.prototype)).messageType="SatelliteAPC",T.prototype.constructor=T,T.prototype.parser=(new o).endianess("little").nest("sid",{type:i.prototype.parser}).uint8("sat_info").uint16("svn").array("pco",{length:3,type:"int16le"}).array("pcv",{length:21,type:"int8"}),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),T.prototype.fieldSpec.push(["sat_info","writeUInt8",1]),T.prototype.fieldSpec.push(["svn","writeUInt16LE",2]),T.prototype.fieldSpec.push(["pco","array","writeInt16LE",function(){return 2},3]),T.prototype.fieldSpec.push(["pcv","array","writeInt8",function(){return 1},21]);var U=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_SATELLITE_APC",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(p.prototype)).messageType="MSG_SSR_SATELLITE_APC",U.prototype.msg_type=1540,U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").array("apc",{type:T.prototype.parser,readUntil:"eof"}),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["apc","array",T.prototype.fieldSpec,function(){return this.fields.array.length},null]);var M=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(p.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_DEP_A",M.prototype.msg_type=1500,M.prototype.constructor=M,M.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).nest("sid",{type:i.prototype.parser}).uint8("update_interval").uint8("iod_ssr").uint8("iod").int32("radial").int32("along").int32("cross").int32("dot_radial").int32("dot_along").int32("dot_cross").int32("c0").int32("c1").int32("c2"),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),M.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),M.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),M.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),M.prototype.fieldSpec.push(["iod","writeUInt8",1]),M.prototype.fieldSpec.push(["radial","writeInt32LE",4]),M.prototype.fieldSpec.push(["along","writeInt32LE",4]),M.prototype.fieldSpec.push(["cross","writeInt32LE",4]),M.prototype.fieldSpec.push(["dot_radial","writeInt32LE",4]),M.prototype.fieldSpec.push(["dot_along","writeInt32LE",4]),M.prototype.fieldSpec.push(["dot_cross","writeInt32LE",4]),M.prototype.fieldSpec.push(["c0","writeInt32LE",4]),M.prototype.fieldSpec.push(["c1","writeInt32LE",4]),M.prototype.fieldSpec.push(["c2","writeInt32LE",4]);var D=function(e,t){return p.call(this,e),this.messageType="STECHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(p.prototype)).messageType="STECHeaderDepA",D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("update_interval").uint8("iod_atmo"),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),D.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),D.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),D.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),D.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]);var O=function(e,t){return p.call(this,e),this.messageType="GriddedCorrectionHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(p.prototype)).messageType="GriddedCorrectionHeaderDepA",O.prototype.constructor=O,O.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint16("num_msgs").uint16("seq_num").uint8("update_interval").uint8("iod_atmo").uint8("tropo_quality_indicator"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),O.prototype.fieldSpec.push(["num_msgs","writeUInt16LE",2]),O.prototype.fieldSpec.push(["seq_num","writeUInt16LE",2]),O.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),O.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]),O.prototype.fieldSpec.push(["tropo_quality_indicator","writeUInt8",1]);var G=function(e,t){return p.call(this,e),this.messageType="GridDefinitionHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(p.prototype)).messageType="GridDefinitionHeaderDepA",G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").uint8("region_size_inverse").uint16("area_width").uint16("lat_nw_corner_enc").uint16("lon_nw_corner_enc").uint8("num_msgs").uint8("seq_num"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["region_size_inverse","writeUInt8",1]),G.prototype.fieldSpec.push(["area_width","writeUInt16LE",2]),G.prototype.fieldSpec.push(["lat_nw_corner_enc","writeUInt16LE",2]),G.prototype.fieldSpec.push(["lon_nw_corner_enc","writeUInt16LE",2]),G.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),G.prototype.fieldSpec.push(["seq_num","writeUInt8",1]);var A=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_STEC_CORRECTION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(p.prototype)).messageType="MSG_SSR_STEC_CORRECTION_DEP_A",A.prototype.msg_type=1515,A.prototype.constructor=A,A.prototype.parser=(new o).endianess("little").nest("header",{type:D.prototype.parser}).array("stec_sat_list",{type:y.prototype.parser,readUntil:"eof"}),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["header",D.prototype.fieldSpec]),A.prototype.fieldSpec.push(["stec_sat_list","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);var C=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(p.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A",C.prototype.msg_type=1520,C.prototype.constructor=C,C.prototype.parser=(new o).endianess("little").nest("header",{type:O.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:h.prototype.parser}).array("stec_residuals",{type:d.prototype.parser,readUntil:"eof"}),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["header",O.prototype.fieldSpec]),C.prototype.fieldSpec.push(["index","writeUInt16LE",2]),C.prototype.fieldSpec.push(["tropo_delay_correction",h.prototype.fieldSpec]),C.prototype.fieldSpec.push(["stec_residuals","array",d.prototype.fieldSpec,function(){return this.fields.array.length},null]);var R=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(p.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_DEP_A",R.prototype.msg_type=1530,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").nest("header",{type:O.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:f.prototype.parser}).array("stec_residuals",{type:_.prototype.parser,readUntil:"eof"}),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["header",O.prototype.fieldSpec]),R.prototype.fieldSpec.push(["index","writeUInt16LE",2]),R.prototype.fieldSpec.push(["tropo_delay_correction",f.prototype.fieldSpec]),R.prototype.fieldSpec.push(["stec_residuals","array",_.prototype.fieldSpec,function(){return this.fields.array.length},null]);var P=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_GRID_DEFINITION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(p.prototype)).messageType="MSG_SSR_GRID_DEFINITION_DEP_A",P.prototype.msg_type=1525,P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").nest("header",{type:G.prototype.parser}).array("rle_list",{type:"uint8",readUntil:"eof"}),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["header",G.prototype.fieldSpec]),P.prototype.fieldSpec.push(["rle_list","array","writeUInt8",function(){return 1},null]);var N=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(p.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS",N.prototype.msg_type=1502,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").array("stub",{type:"uint8",readUntil:"eof"}),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["stub","array","writeUInt8",function(){return 1},null]);var j=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_CODE_PHASE_BIASES_BOUNDS",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(p.prototype)).messageType="MSG_SSR_CODE_PHASE_BIASES_BOUNDS",j.prototype.msg_type=1516,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").array("stub",{type:"uint8",readUntil:"eof"}),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["stub","array","writeUInt8",function(){return 1},null]);var x=function(e,t){return p.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(p.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION",x.prototype.msg_type=1503,x.prototype.constructor=x,x.prototype.parser=(new o).endianess("little").array("stub",{type:"uint8",readUntil:"eof"}),x.prototype.fieldSpec=[],x.prototype.fieldSpec.push(["stub","array","writeUInt8",function(){return 1},null]),e.exports={CodeBiasesContent:a,PhaseBiasesContent:l,STECHeader:c,GriddedCorrectionHeader:u,STECSatElement:y,TroposphericDelayCorrectionNoStd:h,TroposphericDelayCorrection:f,STECResidualNoStd:d,STECResidual:_,1501:S,MsgSsrOrbitClock:S,1505:g,MsgSsrCodeBiases:g,1510:w,MsgSsrPhaseBiases:w,1531:E,MsgSsrStecCorrectionDep:E,1533:m,MsgSsrStecCorrection:m,1532:b,MsgSsrGriddedCorrection:b,1534:v,MsgSsrGriddedCorrectionBounds:v,1526:I,MsgSsrTileDefinitionDep:I,1527:L,MsgSsrTileDefinition:L,SatelliteAPC:T,1540:U,MsgSsrSatelliteApc:U,1500:M,MsgSsrOrbitClockDepA:M,STECHeaderDepA:D,GriddedCorrectionHeaderDepA:O,GridDefinitionHeaderDepA:G,1515:A,MsgSsrStecCorrectionDepA:A,1520:C,MsgSsrGriddedCorrectionNoStdDepA:C,1530:R,MsgSsrGriddedCorrectionDepA:R,1525:P,MsgSsrGridDefinitionDepA:P,1502:N,MsgSsrOrbitClockBounds:N,1516:j,MsgSsrCodePhaseBiasesBounds:j,1503:x,MsgSsrOrbitClockBoundsDegradation:x}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_STARTUP",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_STARTUP",i.prototype.msg_type=65280,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint8("cause").uint8("startup_type").uint16("reserved"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["cause","writeUInt8",1]),i.prototype.fieldSpec.push(["startup_type","writeUInt8",1]),i.prototype.fieldSpec.push(["reserved","writeUInt16LE",2]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_DGNSS_STATUS",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_DGNSS_STATUS",s.prototype.msg_type=65282,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint8("flags").uint16("latency").uint8("num_signals").string("source",{greedy:!0}),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["flags","writeUInt8",1]),s.prototype.fieldSpec.push(["latency","writeUInt16LE",2]),s.prototype.fieldSpec.push(["num_signals","writeUInt8",1]),s.prototype.fieldSpec.push(["source","string",null]);var n=function(e,t){return p.call(this,e),this.messageType="MSG_HEARTBEAT",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(p.prototype)).messageType="MSG_HEARTBEAT",n.prototype.msg_type=65535,n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").uint32("flags"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);var a=function(e,t){return p.call(this,e),this.messageType="SubSystemReport",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(p.prototype)).messageType="SubSystemReport",a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").uint16("component").uint8("generic").uint8("specific"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["component","writeUInt16LE",2]),a.prototype.fieldSpec.push(["generic","writeUInt8",1]),a.prototype.fieldSpec.push(["specific","writeUInt8",1]);var l=function(e,t){return p.call(this,e),this.messageType="MSG_STATUS_REPORT",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(p.prototype)).messageType="MSG_STATUS_REPORT",l.prototype.msg_type=65534,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").uint16("reporting_system").uint16("sbp_version").uint32("sequence").uint32("uptime").array("status",{type:a.prototype.parser,readUntil:"eof"}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["reporting_system","writeUInt16LE",2]),l.prototype.fieldSpec.push(["sbp_version","writeUInt16LE",2]),l.prototype.fieldSpec.push(["sequence","writeUInt32LE",4]),l.prototype.fieldSpec.push(["uptime","writeUInt32LE",4]),l.prototype.fieldSpec.push(["status","array",a.prototype.fieldSpec,function(){return this.fields.array.length},null]);var c=function(e,t){return p.call(this,e),this.messageType="StatusJournalItem",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(p.prototype)).messageType="StatusJournalItem",c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint32("uptime").nest("report",{type:a.prototype.parser}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["uptime","writeUInt32LE",4]),c.prototype.fieldSpec.push(["report",a.prototype.fieldSpec]);var u=function(e,t){return p.call(this,e),this.messageType="MSG_STATUS_JOURNAL",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="MSG_STATUS_JOURNAL",u.prototype.msg_type=65533,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint16("reporting_system").uint16("sbp_version").uint32("total_status_reports").uint8("sequence_descriptor").array("journal",{type:c.prototype.parser,readUntil:"eof"}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["reporting_system","writeUInt16LE",2]),u.prototype.fieldSpec.push(["sbp_version","writeUInt16LE",2]),u.prototype.fieldSpec.push(["total_status_reports","writeUInt32LE",4]),u.prototype.fieldSpec.push(["sequence_descriptor","writeUInt8",1]),u.prototype.fieldSpec.push(["journal","array",c.prototype.fieldSpec,function(){return this.fields.array.length},null]);var y=function(e,t){return p.call(this,e),this.messageType="MSG_INS_STATUS",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="MSG_INS_STATUS",y.prototype.msg_type=65283,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").uint32("flags"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);var h=function(e,t){return p.call(this,e),this.messageType="MSG_CSAC_TELEMETRY",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_CSAC_TELEMETRY",h.prototype.msg_type=65284,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").uint8("id").string("telemetry",{greedy:!0}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["id","writeUInt8",1]),h.prototype.fieldSpec.push(["telemetry","string",null]);var f=function(e,t){return p.call(this,e),this.messageType="MSG_CSAC_TELEMETRY_LABELS",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="MSG_CSAC_TELEMETRY_LABELS",f.prototype.msg_type=65285,f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").uint8("id").string("telemetry_labels",{greedy:!0}),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["id","writeUInt8",1]),f.prototype.fieldSpec.push(["telemetry_labels","string",null]);var d=function(e,t){return p.call(this,e),this.messageType="MSG_INS_UPDATES",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(p.prototype)).messageType="MSG_INS_UPDATES",d.prototype.msg_type=65286,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").uint32("tow").uint8("gnsspos").uint8("gnssvel").uint8("wheelticks").uint8("speed").uint8("nhc").uint8("zerovel"),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),d.prototype.fieldSpec.push(["gnsspos","writeUInt8",1]),d.prototype.fieldSpec.push(["gnssvel","writeUInt8",1]),d.prototype.fieldSpec.push(["wheelticks","writeUInt8",1]),d.prototype.fieldSpec.push(["speed","writeUInt8",1]),d.prototype.fieldSpec.push(["nhc","writeUInt8",1]),d.prototype.fieldSpec.push(["zerovel","writeUInt8",1]);var _=function(e,t){return p.call(this,e),this.messageType="MSG_GNSS_TIME_OFFSET",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(p.prototype)).messageType="MSG_GNSS_TIME_OFFSET",_.prototype.msg_type=65287,_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").int16("weeks").int32("milliseconds").int16("microseconds").uint8("flags"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["weeks","writeInt16LE",2]),_.prototype.fieldSpec.push(["milliseconds","writeInt32LE",4]),_.prototype.fieldSpec.push(["microseconds","writeInt16LE",2]),_.prototype.fieldSpec.push(["flags","writeUInt8",1]);var S=function(e,t){return p.call(this,e),this.messageType="MSG_PPS_TIME",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(p.prototype)).messageType="MSG_PPS_TIME",S.prototype.msg_type=65288,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").uint64("time").uint8("flags"),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["time","writeUInt64LE",8]),S.prototype.fieldSpec.push(["flags","writeUInt8",1]);var g=function(e,t){return p.call(this,e),this.messageType="MSG_SENSOR_AID_EVENT",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(p.prototype)).messageType="MSG_SENSOR_AID_EVENT",g.prototype.msg_type=65289,g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").uint32("time").uint8("sensor_type").uint16("sensor_id").uint8("sensor_state").uint8("n_available_meas").uint8("n_attempted_meas").uint8("n_accepted_meas").uint32("flags"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["time","writeUInt32LE",4]),g.prototype.fieldSpec.push(["sensor_type","writeUInt8",1]),g.prototype.fieldSpec.push(["sensor_id","writeUInt16LE",2]),g.prototype.fieldSpec.push(["sensor_state","writeUInt8",1]),g.prototype.fieldSpec.push(["n_available_meas","writeUInt8",1]),g.prototype.fieldSpec.push(["n_attempted_meas","writeUInt8",1]),g.prototype.fieldSpec.push(["n_accepted_meas","writeUInt8",1]),g.prototype.fieldSpec.push(["flags","writeUInt32LE",4]);var w=function(e,t){return p.call(this,e),this.messageType="MSG_GROUP_META",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(p.prototype)).messageType="MSG_GROUP_META",w.prototype.msg_type=65290,w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").uint8("group_id").uint8("flags").uint8("n_group_msgs").array("group_msgs",{type:"uint16le",length:"n_group_msgs"}),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["group_id","writeUInt8",1]),w.prototype.fieldSpec.push(["flags","writeUInt8",1]),w.prototype.fieldSpec.push(["n_group_msgs","writeUInt8",1]),w.prototype.fieldSpec.push(["group_msgs","array","writeUInt16LE",function(){return 2},"n_group_msgs"]),e.exports={65280:i,MsgStartup:i,65282:s,MsgDgnssStatus:s,65535:n,MsgHeartbeat:n,SubSystemReport:a,65534:l,MsgStatusReport:l,StatusJournalItem:c,65533:u,MsgStatusJournal:u,65283:y,MsgInsStatus:y,65284:h,MsgCsacTelemetry:h,65285:f,MsgCsacTelemetryLabels:f,65286:d,MsgInsUpdates:d,65287:_,MsgGnssTimeOffset:_,65288:S,MsgPpsTime:S,65289:g,MsgSensorAidEvent:g,65290:w,MsgGroupMeta:w}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,r(0).CarrierPhase),s=r(0).GnssSignal,n=r(0).GnssSignalDep,a=r(0).GPSTime,l=r(0).GPSTimeDep,c=(r(0).GPSTimeSec,r(0).SvId,function(e,t){return p.call(this,e),this.messageType="MSG_TRACKING_STATE_DETAILED_DEP_A",this.fields=t||this.parser.parse(e.payload),this});(c.prototype=Object.create(p.prototype)).messageType="MSG_TRACKING_STATE_DETAILED_DEP_A",c.prototype.msg_type=33,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").uint64("recv_time").nest("tot",{type:a.prototype.parser}).uint32("P").uint16("P_std").nest("L",{type:i.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:s.prototype.parser}).int32("doppler").uint16("doppler_std").uint32("uptime").int16("clock_offset").int16("clock_drift").uint16("corr_spacing").int8("acceleration").uint8("sync_flags").uint8("tow_flags").uint8("track_flags").uint8("nav_flags").uint8("pset_flags").uint8("misc_flags"),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["recv_time","writeUInt64LE",8]),c.prototype.fieldSpec.push(["tot",a.prototype.fieldSpec]),c.prototype.fieldSpec.push(["P","writeUInt32LE",4]),c.prototype.fieldSpec.push(["P_std","writeUInt16LE",2]),c.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),c.prototype.fieldSpec.push(["cn0","writeUInt8",1]),c.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),c.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),c.prototype.fieldSpec.push(["doppler","writeInt32LE",4]),c.prototype.fieldSpec.push(["doppler_std","writeUInt16LE",2]),c.prototype.fieldSpec.push(["uptime","writeUInt32LE",4]),c.prototype.fieldSpec.push(["clock_offset","writeInt16LE",2]),c.prototype.fieldSpec.push(["clock_drift","writeInt16LE",2]),c.prototype.fieldSpec.push(["corr_spacing","writeUInt16LE",2]),c.prototype.fieldSpec.push(["acceleration","writeInt8",1]),c.prototype.fieldSpec.push(["sync_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["tow_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["track_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["nav_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["pset_flags","writeUInt8",1]),c.prototype.fieldSpec.push(["misc_flags","writeUInt8",1]);var u=function(e,t){return p.call(this,e),this.messageType="MSG_TRACKING_STATE_DETAILED_DEP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(p.prototype)).messageType="MSG_TRACKING_STATE_DETAILED_DEP",u.prototype.msg_type=17,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").uint64("recv_time").nest("tot",{type:l.prototype.parser}).uint32("P").uint16("P_std").nest("L",{type:i.prototype.parser}).uint8("cn0").uint16("lock").nest("sid",{type:n.prototype.parser}).int32("doppler").uint16("doppler_std").uint32("uptime").int16("clock_offset").int16("clock_drift").uint16("corr_spacing").int8("acceleration").uint8("sync_flags").uint8("tow_flags").uint8("track_flags").uint8("nav_flags").uint8("pset_flags").uint8("misc_flags"),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["recv_time","writeUInt64LE",8]),u.prototype.fieldSpec.push(["tot",l.prototype.fieldSpec]),u.prototype.fieldSpec.push(["P","writeUInt32LE",4]),u.prototype.fieldSpec.push(["P_std","writeUInt16LE",2]),u.prototype.fieldSpec.push(["L",i.prototype.fieldSpec]),u.prototype.fieldSpec.push(["cn0","writeUInt8",1]),u.prototype.fieldSpec.push(["lock","writeUInt16LE",2]),u.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),u.prototype.fieldSpec.push(["doppler","writeInt32LE",4]),u.prototype.fieldSpec.push(["doppler_std","writeUInt16LE",2]),u.prototype.fieldSpec.push(["uptime","writeUInt32LE",4]),u.prototype.fieldSpec.push(["clock_offset","writeInt16LE",2]),u.prototype.fieldSpec.push(["clock_drift","writeInt16LE",2]),u.prototype.fieldSpec.push(["corr_spacing","writeUInt16LE",2]),u.prototype.fieldSpec.push(["acceleration","writeInt8",1]),u.prototype.fieldSpec.push(["sync_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["tow_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["track_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["nav_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["pset_flags","writeUInt8",1]),u.prototype.fieldSpec.push(["misc_flags","writeUInt8",1]);var y=function(e,t){return p.call(this,e),this.messageType="TrackingChannelState",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(p.prototype)).messageType="TrackingChannelState",y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").nest("sid",{type:s.prototype.parser}).uint8("fcn").uint8("cn0"),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),y.prototype.fieldSpec.push(["fcn","writeUInt8",1]),y.prototype.fieldSpec.push(["cn0","writeUInt8",1]);var h=function(e,t){return p.call(this,e),this.messageType="MSG_TRACKING_STATE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(p.prototype)).messageType="MSG_TRACKING_STATE",h.prototype.msg_type=65,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").array("states",{type:y.prototype.parser,readUntil:"eof"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["states","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);var f=function(e,t){return p.call(this,e),this.messageType="MeasurementState",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(p.prototype)).messageType="MeasurementState",f.prototype.constructor=f,f.prototype.parser=(new o).endianess("little").nest("mesid",{type:s.prototype.parser}).uint8("cn0"),f.prototype.fieldSpec=[],f.prototype.fieldSpec.push(["mesid",s.prototype.fieldSpec]),f.prototype.fieldSpec.push(["cn0","writeUInt8",1]);var d=function(e,t){return p.call(this,e),this.messageType="MSG_MEASUREMENT_STATE",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(p.prototype)).messageType="MSG_MEASUREMENT_STATE",d.prototype.msg_type=97,d.prototype.constructor=d,d.prototype.parser=(new o).endianess("little").array("states",{type:f.prototype.parser,readUntil:"eof"}),d.prototype.fieldSpec=[],d.prototype.fieldSpec.push(["states","array",f.prototype.fieldSpec,function(){return this.fields.array.length},null]);var _=function(e,t){return p.call(this,e),this.messageType="TrackingChannelCorrelation",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(p.prototype)).messageType="TrackingChannelCorrelation",_.prototype.constructor=_,_.prototype.parser=(new o).endianess("little").int16("I").int16("Q"),_.prototype.fieldSpec=[],_.prototype.fieldSpec.push(["I","writeInt16LE",2]),_.prototype.fieldSpec.push(["Q","writeInt16LE",2]);var S=function(e,t){return p.call(this,e),this.messageType="MSG_TRACKING_IQ",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(p.prototype)).messageType="MSG_TRACKING_IQ",S.prototype.msg_type=45,S.prototype.constructor=S,S.prototype.parser=(new o).endianess("little").uint8("channel").nest("sid",{type:s.prototype.parser}).array("corrs",{length:3,type:_.prototype.parser}),S.prototype.fieldSpec=[],S.prototype.fieldSpec.push(["channel","writeUInt8",1]),S.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),S.prototype.fieldSpec.push(["corrs","array",_.prototype.fieldSpec,function(){return this.fields.array.length},3]);var g=function(e,t){return p.call(this,e),this.messageType="TrackingChannelCorrelationDep",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(p.prototype)).messageType="TrackingChannelCorrelationDep",g.prototype.constructor=g,g.prototype.parser=(new o).endianess("little").int32("I").int32("Q"),g.prototype.fieldSpec=[],g.prototype.fieldSpec.push(["I","writeInt32LE",4]),g.prototype.fieldSpec.push(["Q","writeInt32LE",4]);var w=function(e,t){return p.call(this,e),this.messageType="MSG_TRACKING_IQ_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(p.prototype)).messageType="MSG_TRACKING_IQ_DEP_B",w.prototype.msg_type=44,w.prototype.constructor=w,w.prototype.parser=(new o).endianess("little").uint8("channel").nest("sid",{type:s.prototype.parser}).array("corrs",{length:3,type:g.prototype.parser}),w.prototype.fieldSpec=[],w.prototype.fieldSpec.push(["channel","writeUInt8",1]),w.prototype.fieldSpec.push(["sid",s.prototype.fieldSpec]),w.prototype.fieldSpec.push(["corrs","array",g.prototype.fieldSpec,function(){return this.fields.array.length},3]);var E=function(e,t){return p.call(this,e),this.messageType="MSG_TRACKING_IQ_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(p.prototype)).messageType="MSG_TRACKING_IQ_DEP_A",E.prototype.msg_type=28,E.prototype.constructor=E,E.prototype.parser=(new o).endianess("little").uint8("channel").nest("sid",{type:n.prototype.parser}).array("corrs",{length:3,type:g.prototype.parser}),E.prototype.fieldSpec=[],E.prototype.fieldSpec.push(["channel","writeUInt8",1]),E.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),E.prototype.fieldSpec.push(["corrs","array",g.prototype.fieldSpec,function(){return this.fields.array.length},3]);var m=function(e,t){return p.call(this,e),this.messageType="TrackingChannelStateDepA",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(p.prototype)).messageType="TrackingChannelStateDepA",m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").uint8("state").uint8("prn").floatle("cn0"),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["state","writeUInt8",1]),m.prototype.fieldSpec.push(["prn","writeUInt8",1]),m.prototype.fieldSpec.push(["cn0","writeFloatLE",4]);var b=function(e,t){return p.call(this,e),this.messageType="MSG_TRACKING_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(p.prototype)).messageType="MSG_TRACKING_STATE_DEP_A",b.prototype.msg_type=22,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").array("states",{type:m.prototype.parser,readUntil:"eof"}),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["states","array",m.prototype.fieldSpec,function(){return this.fields.array.length},null]);var v=function(e,t){return p.call(this,e),this.messageType="TrackingChannelStateDepB",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(p.prototype)).messageType="TrackingChannelStateDepB",v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").uint8("state").nest("sid",{type:n.prototype.parser}).floatle("cn0"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["state","writeUInt8",1]),v.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),v.prototype.fieldSpec.push(["cn0","writeFloatLE",4]);var I=function(e,t){return p.call(this,e),this.messageType="MSG_TRACKING_STATE_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(p.prototype)).messageType="MSG_TRACKING_STATE_DEP_B",I.prototype.msg_type=19,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").array("states",{type:v.prototype.parser,readUntil:"eof"}),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["states","array",v.prototype.fieldSpec,function(){return this.fields.array.length},null]),e.exports={33:c,MsgTrackingStateDetailedDepA:c,17:u,MsgTrackingStateDetailedDep:u,TrackingChannelState:y,65:h,MsgTrackingState:h,MeasurementState:f,97:d,MsgMeasurementState:d,TrackingChannelCorrelation:_,45:S,MsgTrackingIq:S,TrackingChannelCorrelationDep:g,44:w,MsgTrackingIqDepB:w,28:E,MsgTrackingIqDepA:E,TrackingChannelStateDepA:m,22:b,MsgTrackingStateDepA:b,TrackingChannelStateDepB:v,19:I,MsgTrackingStateDepB:I}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_USER_DATA",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_USER_DATA",i.prototype.msg_type=2048,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").array("contents",{type:"uint8",readUntil:"eof"}),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["contents","array","writeUInt8",function(){return 1},null]),e.exports={2048:i,MsgUserData:i}},function(e,t,r){var p=r(2),o=r(4),i=(r(3),r(1).UINT64,function(e,t){return p.call(this,e),this.messageType="MSG_ODOMETRY",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(p.prototype)).messageType="MSG_ODOMETRY",i.prototype.msg_type=2307,i.prototype.constructor=i,i.prototype.parser=(new o).endianess("little").uint32("tow").int32("velocity").uint8("flags"),i.prototype.fieldSpec=[],i.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),i.prototype.fieldSpec.push(["velocity","writeInt32LE",4]),i.prototype.fieldSpec.push(["flags","writeUInt8",1]);var s=function(e,t){return p.call(this,e),this.messageType="MSG_WHEELTICK",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(p.prototype)).messageType="MSG_WHEELTICK",s.prototype.msg_type=2308,s.prototype.constructor=s,s.prototype.parser=(new o).endianess("little").uint64("time").uint8("flags").uint8("source").int32("ticks"),s.prototype.fieldSpec=[],s.prototype.fieldSpec.push(["time","writeUInt64LE",8]),s.prototype.fieldSpec.push(["flags","writeUInt8",1]),s.prototype.fieldSpec.push(["source","writeUInt8",1]),s.prototype.fieldSpec.push(["ticks","writeInt32LE",4]),e.exports={2307:i,MsgOdometry:i,2308:s,MsgWheeltick:s}}]); \ No newline at end of file diff --git a/javascript/sbp/integrity.js b/javascript/sbp/integrity.js new file mode 100644 index 0000000000..8d06bb2af0 --- /dev/null +++ b/javascript/sbp/integrity.js @@ -0,0 +1,202 @@ +/** + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * This source is subject to the license found in the file 'LICENSE' which must + * be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/********************** + * Automatically generated from piksi/yaml/swiftnav/sbp/integrity.yaml with generate.py. + * Don't edit this by hand! + ********************** + * Package description: + * + * Integrity flag messages +***********************/ + +var SBP = require('./sbp'); +var Parser = require('./parser'); +var Int64 = require('node-int64'); +var UInt64 = require('cuint').UINT64; +var CarrierPhase = require("./gnss").CarrierPhase; +var GnssSignal = require("./gnss").GnssSignal; +var GnssSignalDep = require("./gnss").GnssSignalDep; +var GPSTime = require("./gnss").GPSTime; +var GPSTimeDep = require("./gnss").GPSTimeDep; +var GPSTimeSec = require("./gnss").GPSTimeSec; +var SvId = require("./gnss").SvId; + +/** + * SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BB9). + * + + * Fields in the SBP payload (`sbp.payload`): + * @field stub array + * + * @param sbp An SBP object with a payload to be decoded. + */ +var MsgSsrFlagHighLevel = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_SSR_FLAG_HIGH_LEVEL"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgSsrFlagHighLevel.prototype = Object.create(SBP.prototype); +MsgSsrFlagHighLevel.prototype.messageType = "MSG_SSR_FLAG_HIGH_LEVEL"; +MsgSsrFlagHighLevel.prototype.msg_type = 0x0BB9; +MsgSsrFlagHighLevel.prototype.constructor = MsgSsrFlagHighLevel; +MsgSsrFlagHighLevel.prototype.parser = new Parser() + .endianess('little') + .array('stub', { type: 'uint8', readUntil: 'eof' }); +MsgSsrFlagHighLevel.prototype.fieldSpec = []; +MsgSsrFlagHighLevel.prototype.fieldSpec.push(['stub', 'array', 'writeUInt8', function () { return 1; }, null]); + +/** + * SBP class for message MSG_SSR_FLAG_SATELLITES (0x0BBD). + * + + * Fields in the SBP payload (`sbp.payload`): + * @field stub array + * + * @param sbp An SBP object with a payload to be decoded. + */ +var MsgSsrFlagSatellites = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_SSR_FLAG_SATELLITES"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgSsrFlagSatellites.prototype = Object.create(SBP.prototype); +MsgSsrFlagSatellites.prototype.messageType = "MSG_SSR_FLAG_SATELLITES"; +MsgSsrFlagSatellites.prototype.msg_type = 0x0BBD; +MsgSsrFlagSatellites.prototype.constructor = MsgSsrFlagSatellites; +MsgSsrFlagSatellites.prototype.parser = new Parser() + .endianess('little') + .array('stub', { type: 'uint8', readUntil: 'eof' }); +MsgSsrFlagSatellites.prototype.fieldSpec = []; +MsgSsrFlagSatellites.prototype.fieldSpec.push(['stub', 'array', 'writeUInt8', function () { return 1; }, null]); + +/** + * SBP class for message MSG_SSR_FLAG_TROPO_GRID_POINTS (0x0BC3). + * + + * Fields in the SBP payload (`sbp.payload`): + * @field stub array + * + * @param sbp An SBP object with a payload to be decoded. + */ +var MsgSsrFlagTropoGridPoints = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_SSR_FLAG_TROPO_GRID_POINTS"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgSsrFlagTropoGridPoints.prototype = Object.create(SBP.prototype); +MsgSsrFlagTropoGridPoints.prototype.messageType = "MSG_SSR_FLAG_TROPO_GRID_POINTS"; +MsgSsrFlagTropoGridPoints.prototype.msg_type = 0x0BC3; +MsgSsrFlagTropoGridPoints.prototype.constructor = MsgSsrFlagTropoGridPoints; +MsgSsrFlagTropoGridPoints.prototype.parser = new Parser() + .endianess('little') + .array('stub', { type: 'uint8', readUntil: 'eof' }); +MsgSsrFlagTropoGridPoints.prototype.fieldSpec = []; +MsgSsrFlagTropoGridPoints.prototype.fieldSpec.push(['stub', 'array', 'writeUInt8', function () { return 1; }, null]); + +/** + * SBP class for message MSG_SSR_FLAG_IONO_GRID_POINTS (0x0BC7). + * + + * Fields in the SBP payload (`sbp.payload`): + * @field stub array + * + * @param sbp An SBP object with a payload to be decoded. + */ +var MsgSsrFlagIonoGridPoints = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_SSR_FLAG_IONO_GRID_POINTS"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgSsrFlagIonoGridPoints.prototype = Object.create(SBP.prototype); +MsgSsrFlagIonoGridPoints.prototype.messageType = "MSG_SSR_FLAG_IONO_GRID_POINTS"; +MsgSsrFlagIonoGridPoints.prototype.msg_type = 0x0BC7; +MsgSsrFlagIonoGridPoints.prototype.constructor = MsgSsrFlagIonoGridPoints; +MsgSsrFlagIonoGridPoints.prototype.parser = new Parser() + .endianess('little') + .array('stub', { type: 'uint8', readUntil: 'eof' }); +MsgSsrFlagIonoGridPoints.prototype.fieldSpec = []; +MsgSsrFlagIonoGridPoints.prototype.fieldSpec.push(['stub', 'array', 'writeUInt8', function () { return 1; }, null]); + +/** + * SBP class for message MSG_SSR_FLAG_IONO_TILE_SAT_LOS (0x0BCD). + * + + * Fields in the SBP payload (`sbp.payload`): + * @field stub array + * + * @param sbp An SBP object with a payload to be decoded. + */ +var MsgSsrFlagIonoTileSatLos = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_SSR_FLAG_IONO_TILE_SAT_LOS"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgSsrFlagIonoTileSatLos.prototype = Object.create(SBP.prototype); +MsgSsrFlagIonoTileSatLos.prototype.messageType = "MSG_SSR_FLAG_IONO_TILE_SAT_LOS"; +MsgSsrFlagIonoTileSatLos.prototype.msg_type = 0x0BCD; +MsgSsrFlagIonoTileSatLos.prototype.constructor = MsgSsrFlagIonoTileSatLos; +MsgSsrFlagIonoTileSatLos.prototype.parser = new Parser() + .endianess('little') + .array('stub', { type: 'uint8', readUntil: 'eof' }); +MsgSsrFlagIonoTileSatLos.prototype.fieldSpec = []; +MsgSsrFlagIonoTileSatLos.prototype.fieldSpec.push(['stub', 'array', 'writeUInt8', function () { return 1; }, null]); + +/** + * SBP class for message MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS (0x0BD1). + * + + * Fields in the SBP payload (`sbp.payload`): + * @field stub array + * + * @param sbp An SBP object with a payload to be decoded. + */ +var MsgSsrFlagIonoGridPointSatLos = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgSsrFlagIonoGridPointSatLos.prototype = Object.create(SBP.prototype); +MsgSsrFlagIonoGridPointSatLos.prototype.messageType = "MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS"; +MsgSsrFlagIonoGridPointSatLos.prototype.msg_type = 0x0BD1; +MsgSsrFlagIonoGridPointSatLos.prototype.constructor = MsgSsrFlagIonoGridPointSatLos; +MsgSsrFlagIonoGridPointSatLos.prototype.parser = new Parser() + .endianess('little') + .array('stub', { type: 'uint8', readUntil: 'eof' }); +MsgSsrFlagIonoGridPointSatLos.prototype.fieldSpec = []; +MsgSsrFlagIonoGridPointSatLos.prototype.fieldSpec.push(['stub', 'array', 'writeUInt8', function () { return 1; }, null]); + +module.exports = { + 0x0BB9: MsgSsrFlagHighLevel, + MsgSsrFlagHighLevel: MsgSsrFlagHighLevel, + 0x0BBD: MsgSsrFlagSatellites, + MsgSsrFlagSatellites: MsgSsrFlagSatellites, + 0x0BC3: MsgSsrFlagTropoGridPoints, + MsgSsrFlagTropoGridPoints: MsgSsrFlagTropoGridPoints, + 0x0BC7: MsgSsrFlagIonoGridPoints, + MsgSsrFlagIonoGridPoints: MsgSsrFlagIonoGridPoints, + 0x0BCD: MsgSsrFlagIonoTileSatLos, + MsgSsrFlagIonoTileSatLos: MsgSsrFlagIonoTileSatLos, + 0x0BD1: MsgSsrFlagIonoGridPointSatLos, + MsgSsrFlagIonoGridPointSatLos: MsgSsrFlagIonoGridPointSatLos, +} \ No newline at end of file diff --git a/javascript/sbp/msg.js b/javascript/sbp/msg.js index 039344028b..ed680ec013 100644 --- a/javascript/sbp/msg.js +++ b/javascript/sbp/msg.js @@ -95,6 +95,7 @@ var sbpImports = { flash: require('./flash.js'), gnss: require('./gnss.js'), imu: require('./imu.js'), + integrity: require('./integrity.js'), linux: require('./linux.js'), logging: require('./logging.js'), mag: require('./mag.js'), diff --git a/javascript/sbp/navigation.js b/javascript/sbp/navigation.js index 31df4792a9..ac5c673027 100644 --- a/javascript/sbp/navigation.js +++ b/javascript/sbp/navigation.js @@ -2132,6 +2132,60 @@ MsgProtectionLevel.prototype.fieldSpec.push(['pitch', 'writeInt32LE', 4]); MsgProtectionLevel.prototype.fieldSpec.push(['heading', 'writeInt32LE', 4]); MsgProtectionLevel.prototype.fieldSpec.push(['flags', 'writeUInt32LE', 4]); +/** + * SBP class for message MSG_GPS_LEAP_SECOND (0x023A). + * + * Emulates the GPS CNAV message, reserving bytes for future broadcast of the drift + * model parameters. + * + * Fields in the SBP payload (`sbp.payload`): + * @field stub array + * + * @param sbp An SBP object with a payload to be decoded. + */ +var MsgGpsLeapSecond = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_GPS_LEAP_SECOND"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgGpsLeapSecond.prototype = Object.create(SBP.prototype); +MsgGpsLeapSecond.prototype.messageType = "MSG_GPS_LEAP_SECOND"; +MsgGpsLeapSecond.prototype.msg_type = 0x023A; +MsgGpsLeapSecond.prototype.constructor = MsgGpsLeapSecond; +MsgGpsLeapSecond.prototype.parser = new Parser() + .endianess('little') + .array('stub', { type: 'uint8', readUntil: 'eof' }); +MsgGpsLeapSecond.prototype.fieldSpec = []; +MsgGpsLeapSecond.prototype.fieldSpec.push(['stub', 'array', 'writeUInt8', function () { return 1; }, null]); + +/** + * SBP class for message MSG_ITRF (0x0244). + * + + * Fields in the SBP payload (`sbp.payload`): + * @field stub array + * + * @param sbp An SBP object with a payload to be decoded. + */ +var MsgItrf = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_ITRF"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgItrf.prototype = Object.create(SBP.prototype); +MsgItrf.prototype.messageType = "MSG_ITRF"; +MsgItrf.prototype.msg_type = 0x0244; +MsgItrf.prototype.constructor = MsgItrf; +MsgItrf.prototype.parser = new Parser() + .endianess('little') + .array('stub', { type: 'uint8', readUntil: 'eof' }); +MsgItrf.prototype.fieldSpec = []; +MsgItrf.prototype.fieldSpec.push(['stub', 'array', 'writeUInt8', function () { return 1; }, null]); + module.exports = { 0x0102: MsgGpsTime, MsgGpsTime: MsgGpsTime, @@ -2210,4 +2264,8 @@ module.exports = { MsgProtectionLevelDepA: MsgProtectionLevelDepA, 0x0217: MsgProtectionLevel, MsgProtectionLevel: MsgProtectionLevel, + 0x023A: MsgGpsLeapSecond, + MsgGpsLeapSecond: MsgGpsLeapSecond, + 0x0244: MsgItrf, + MsgItrf: MsgItrf, } \ No newline at end of file diff --git a/javascript/sbp/ssr.js b/javascript/sbp/ssr.js index f0b149b2b6..0f7241ed66 100644 --- a/javascript/sbp/ssr.js +++ b/javascript/sbp/ssr.js @@ -521,7 +521,7 @@ MsgSsrPhaseBiases.prototype.fieldSpec.push(['yaw_rate', 'writeInt8', 1]); MsgSsrPhaseBiases.prototype.fieldSpec.push(['biases', 'array', PhaseBiasesContent.prototype.fieldSpec, function () { return this.fields.array.length; }, null]); /** - * SBP class for message MSG_SSR_STEC_CORRECTION (0x05FB). + * SBP class for message MSG_SSR_STEC_CORRECTION_DEP (0x05FB). * * The Slant Total Electron Content per space vehicle, given as polynomial * approximation for a given tile. This should be combined with the @@ -535,6 +535,34 @@ MsgSsrPhaseBiases.prototype.fieldSpec.push(['biases', 'array', PhaseBiasesConten * * @param sbp An SBP object with a payload to be decoded. */ +var MsgSsrStecCorrectionDep = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_SSR_STEC_CORRECTION_DEP"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgSsrStecCorrectionDep.prototype = Object.create(SBP.prototype); +MsgSsrStecCorrectionDep.prototype.messageType = "MSG_SSR_STEC_CORRECTION_DEP"; +MsgSsrStecCorrectionDep.prototype.msg_type = 0x05FB; +MsgSsrStecCorrectionDep.prototype.constructor = MsgSsrStecCorrectionDep; +MsgSsrStecCorrectionDep.prototype.parser = new Parser() + .endianess('little') + .nest('header', { type: STECHeader.prototype.parser }) + .array('stec_sat_list', { type: STECSatElement.prototype.parser, readUntil: 'eof' }); +MsgSsrStecCorrectionDep.prototype.fieldSpec = []; +MsgSsrStecCorrectionDep.prototype.fieldSpec.push(['header', STECHeader.prototype.fieldSpec]); +MsgSsrStecCorrectionDep.prototype.fieldSpec.push(['stec_sat_list', 'array', STECSatElement.prototype.fieldSpec, function () { return this.fields.array.length; }, null]); + +/** + * SBP class for message MSG_SSR_STEC_CORRECTION (0x05FD). + * + + * Fields in the SBP payload (`sbp.payload`): + * @field stub array + * + * @param sbp An SBP object with a payload to be decoded. + */ var MsgSsrStecCorrection = function (sbp, fields) { SBP.call(this, sbp); this.messageType = "MSG_SSR_STEC_CORRECTION"; @@ -544,15 +572,13 @@ var MsgSsrStecCorrection = function (sbp, fields) { }; MsgSsrStecCorrection.prototype = Object.create(SBP.prototype); MsgSsrStecCorrection.prototype.messageType = "MSG_SSR_STEC_CORRECTION"; -MsgSsrStecCorrection.prototype.msg_type = 0x05FB; +MsgSsrStecCorrection.prototype.msg_type = 0x05FD; MsgSsrStecCorrection.prototype.constructor = MsgSsrStecCorrection; MsgSsrStecCorrection.prototype.parser = new Parser() .endianess('little') - .nest('header', { type: STECHeader.prototype.parser }) - .array('stec_sat_list', { type: STECSatElement.prototype.parser, readUntil: 'eof' }); + .array('stub', { type: 'uint8', readUntil: 'eof' }); MsgSsrStecCorrection.prototype.fieldSpec = []; -MsgSsrStecCorrection.prototype.fieldSpec.push(['header', STECHeader.prototype.fieldSpec]); -MsgSsrStecCorrection.prototype.fieldSpec.push(['stec_sat_list', 'array', STECSatElement.prototype.fieldSpec, function () { return this.fields.array.length; }, null]); +MsgSsrStecCorrection.prototype.fieldSpec.push(['stub', 'array', 'writeUInt8', function () { return 1; }, null]); /** * SBP class for message MSG_SSR_GRIDDED_CORRECTION (0x05FC). @@ -592,13 +618,39 @@ MsgSsrGriddedCorrection.prototype.fieldSpec.push(['tropo_delay_correction', Trop MsgSsrGriddedCorrection.prototype.fieldSpec.push(['stec_residuals', 'array', STECResidual.prototype.fieldSpec, function () { return this.fields.array.length; }, null]); /** - * SBP class for message MSG_SSR_TILE_DEFINITION (0x05F6). + * SBP class for message MSG_SSR_GRIDDED_CORRECTION_BOUNDS (0x05FE). + * + + * Fields in the SBP payload (`sbp.payload`): + * @field stub array + * + * @param sbp An SBP object with a payload to be decoded. + */ +var MsgSsrGriddedCorrectionBounds = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_SSR_GRIDDED_CORRECTION_BOUNDS"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgSsrGriddedCorrectionBounds.prototype = Object.create(SBP.prototype); +MsgSsrGriddedCorrectionBounds.prototype.messageType = "MSG_SSR_GRIDDED_CORRECTION_BOUNDS"; +MsgSsrGriddedCorrectionBounds.prototype.msg_type = 0x05FE; +MsgSsrGriddedCorrectionBounds.prototype.constructor = MsgSsrGriddedCorrectionBounds; +MsgSsrGriddedCorrectionBounds.prototype.parser = new Parser() + .endianess('little') + .array('stub', { type: 'uint8', readUntil: 'eof' }); +MsgSsrGriddedCorrectionBounds.prototype.fieldSpec = []; +MsgSsrGriddedCorrectionBounds.prototype.fieldSpec.push(['stub', 'array', 'writeUInt8', function () { return 1; }, null]); + +/** + * SBP class for message MSG_SSR_TILE_DEFINITION_DEP (0x05F6). * * Provides the correction point coordinates for the atmospheric correction values - * in the MSG_SSR_STEC_CORRECTION and MSG_SSR_GRIDDED_CORRECTION messages. Based - * on ETSI TS 137 355 V16.1.0 (LTE Positioning Protocol) information element GNSS- - * SSR-CorrectionPoints. SBP only supports gridded arrays of correction points, not - * lists of points. + * in the MSG_SSR_STEC_CORRECTION_DEP and MSG_SSR_GRIDDED_CORRECTION messages. + * Based on ETSI TS 137 355 V16.1.0 (LTE Positioning Protocol) information element + * GNSS-SSR-CorrectionPoints. SBP only supports gridded arrays of correction + * points, not lists of points. * * Fields in the SBP payload (`sbp.payload`): * @field tile_set_id number (unsigned 16-bit int, 2 bytes) Unique identifier of the tile set this tile belongs to. @@ -631,18 +683,18 @@ MsgSsrGriddedCorrection.prototype.fieldSpec.push(['stec_residuals', 'array', STE * * @param sbp An SBP object with a payload to be decoded. */ -var MsgSsrTileDefinition = function (sbp, fields) { +var MsgSsrTileDefinitionDep = function (sbp, fields) { SBP.call(this, sbp); - this.messageType = "MSG_SSR_TILE_DEFINITION"; + this.messageType = "MSG_SSR_TILE_DEFINITION_DEP"; this.fields = (fields || this.parser.parse(sbp.payload)); return this; }; -MsgSsrTileDefinition.prototype = Object.create(SBP.prototype); -MsgSsrTileDefinition.prototype.messageType = "MSG_SSR_TILE_DEFINITION"; -MsgSsrTileDefinition.prototype.msg_type = 0x05F6; -MsgSsrTileDefinition.prototype.constructor = MsgSsrTileDefinition; -MsgSsrTileDefinition.prototype.parser = new Parser() +MsgSsrTileDefinitionDep.prototype = Object.create(SBP.prototype); +MsgSsrTileDefinitionDep.prototype.messageType = "MSG_SSR_TILE_DEFINITION_DEP"; +MsgSsrTileDefinitionDep.prototype.msg_type = 0x05F6; +MsgSsrTileDefinitionDep.prototype.constructor = MsgSsrTileDefinitionDep; +MsgSsrTileDefinitionDep.prototype.parser = new Parser() .endianess('little') .uint16('tile_set_id') .uint16('tile_id') @@ -653,16 +705,47 @@ MsgSsrTileDefinition.prototype.parser = new Parser() .uint16('rows') .uint16('cols') .uint64('bitmask'); +MsgSsrTileDefinitionDep.prototype.fieldSpec = []; +MsgSsrTileDefinitionDep.prototype.fieldSpec.push(['tile_set_id', 'writeUInt16LE', 2]); +MsgSsrTileDefinitionDep.prototype.fieldSpec.push(['tile_id', 'writeUInt16LE', 2]); +MsgSsrTileDefinitionDep.prototype.fieldSpec.push(['corner_nw_lat', 'writeInt16LE', 2]); +MsgSsrTileDefinitionDep.prototype.fieldSpec.push(['corner_nw_lon', 'writeInt16LE', 2]); +MsgSsrTileDefinitionDep.prototype.fieldSpec.push(['spacing_lat', 'writeUInt16LE', 2]); +MsgSsrTileDefinitionDep.prototype.fieldSpec.push(['spacing_lon', 'writeUInt16LE', 2]); +MsgSsrTileDefinitionDep.prototype.fieldSpec.push(['rows', 'writeUInt16LE', 2]); +MsgSsrTileDefinitionDep.prototype.fieldSpec.push(['cols', 'writeUInt16LE', 2]); +MsgSsrTileDefinitionDep.prototype.fieldSpec.push(['bitmask', 'writeUInt64LE', 8]); + +/** + * SBP class for message MSG_SSR_TILE_DEFINITION (0x05F7). + * + * Provides the correction point coordinates for the atmospheric correction values + * in the MSG_SSR_STEC_CORRECTION and MSG_SSR_GRIDDED_CORRECTION messages. Based + * on ETSI TS 137 355 V16.1.0 (LTE Positioning Protocol) information element GNSS- + * SSR-CorrectionPoints. SBP only supports gridded arrays of correction points, not + * lists of points. + * + * Fields in the SBP payload (`sbp.payload`): + * @field stub array + * + * @param sbp An SBP object with a payload to be decoded. + */ +var MsgSsrTileDefinition = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_SSR_TILE_DEFINITION"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgSsrTileDefinition.prototype = Object.create(SBP.prototype); +MsgSsrTileDefinition.prototype.messageType = "MSG_SSR_TILE_DEFINITION"; +MsgSsrTileDefinition.prototype.msg_type = 0x05F7; +MsgSsrTileDefinition.prototype.constructor = MsgSsrTileDefinition; +MsgSsrTileDefinition.prototype.parser = new Parser() + .endianess('little') + .array('stub', { type: 'uint8', readUntil: 'eof' }); MsgSsrTileDefinition.prototype.fieldSpec = []; -MsgSsrTileDefinition.prototype.fieldSpec.push(['tile_set_id', 'writeUInt16LE', 2]); -MsgSsrTileDefinition.prototype.fieldSpec.push(['tile_id', 'writeUInt16LE', 2]); -MsgSsrTileDefinition.prototype.fieldSpec.push(['corner_nw_lat', 'writeInt16LE', 2]); -MsgSsrTileDefinition.prototype.fieldSpec.push(['corner_nw_lon', 'writeInt16LE', 2]); -MsgSsrTileDefinition.prototype.fieldSpec.push(['spacing_lat', 'writeUInt16LE', 2]); -MsgSsrTileDefinition.prototype.fieldSpec.push(['spacing_lon', 'writeUInt16LE', 2]); -MsgSsrTileDefinition.prototype.fieldSpec.push(['rows', 'writeUInt16LE', 2]); -MsgSsrTileDefinition.prototype.fieldSpec.push(['cols', 'writeUInt16LE', 2]); -MsgSsrTileDefinition.prototype.fieldSpec.push(['bitmask', 'writeUInt64LE', 8]); +MsgSsrTileDefinition.prototype.fieldSpec.push(['stub', 'array', 'writeUInt8', function () { return 1; }, null]); /** * SBP class for message fragment SatelliteAPC @@ -1058,6 +1141,84 @@ MsgSsrGridDefinitionDepA.prototype.fieldSpec = []; MsgSsrGridDefinitionDepA.prototype.fieldSpec.push(['header', GridDefinitionHeaderDepA.prototype.fieldSpec]); MsgSsrGridDefinitionDepA.prototype.fieldSpec.push(['rle_list', 'array', 'writeUInt8', function () { return 1; }, null]); +/** + * SBP class for message MSG_SSR_ORBIT_CLOCK_BOUNDS (0x05DE). + * + + * Fields in the SBP payload (`sbp.payload`): + * @field stub array + * + * @param sbp An SBP object with a payload to be decoded. + */ +var MsgSsrOrbitClockBounds = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_SSR_ORBIT_CLOCK_BOUNDS"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgSsrOrbitClockBounds.prototype = Object.create(SBP.prototype); +MsgSsrOrbitClockBounds.prototype.messageType = "MSG_SSR_ORBIT_CLOCK_BOUNDS"; +MsgSsrOrbitClockBounds.prototype.msg_type = 0x05DE; +MsgSsrOrbitClockBounds.prototype.constructor = MsgSsrOrbitClockBounds; +MsgSsrOrbitClockBounds.prototype.parser = new Parser() + .endianess('little') + .array('stub', { type: 'uint8', readUntil: 'eof' }); +MsgSsrOrbitClockBounds.prototype.fieldSpec = []; +MsgSsrOrbitClockBounds.prototype.fieldSpec.push(['stub', 'array', 'writeUInt8', function () { return 1; }, null]); + +/** + * SBP class for message MSG_SSR_CODE_PHASE_BIASES_BOUNDS (0x05EC). + * + + * Fields in the SBP payload (`sbp.payload`): + * @field stub array + * + * @param sbp An SBP object with a payload to be decoded. + */ +var MsgSsrCodePhaseBiasesBounds = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_SSR_CODE_PHASE_BIASES_BOUNDS"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgSsrCodePhaseBiasesBounds.prototype = Object.create(SBP.prototype); +MsgSsrCodePhaseBiasesBounds.prototype.messageType = "MSG_SSR_CODE_PHASE_BIASES_BOUNDS"; +MsgSsrCodePhaseBiasesBounds.prototype.msg_type = 0x05EC; +MsgSsrCodePhaseBiasesBounds.prototype.constructor = MsgSsrCodePhaseBiasesBounds; +MsgSsrCodePhaseBiasesBounds.prototype.parser = new Parser() + .endianess('little') + .array('stub', { type: 'uint8', readUntil: 'eof' }); +MsgSsrCodePhaseBiasesBounds.prototype.fieldSpec = []; +MsgSsrCodePhaseBiasesBounds.prototype.fieldSpec.push(['stub', 'array', 'writeUInt8', function () { return 1; }, null]); + +/** + * SBP class for message MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION (0x05DF). + * + + * Fields in the SBP payload (`sbp.payload`): + * @field stub array + * + * @param sbp An SBP object with a payload to be decoded. + */ +var MsgSsrOrbitClockBoundsDegradation = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgSsrOrbitClockBoundsDegradation.prototype = Object.create(SBP.prototype); +MsgSsrOrbitClockBoundsDegradation.prototype.messageType = "MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION"; +MsgSsrOrbitClockBoundsDegradation.prototype.msg_type = 0x05DF; +MsgSsrOrbitClockBoundsDegradation.prototype.constructor = MsgSsrOrbitClockBoundsDegradation; +MsgSsrOrbitClockBoundsDegradation.prototype.parser = new Parser() + .endianess('little') + .array('stub', { type: 'uint8', readUntil: 'eof' }); +MsgSsrOrbitClockBoundsDegradation.prototype.fieldSpec = []; +MsgSsrOrbitClockBoundsDegradation.prototype.fieldSpec.push(['stub', 'array', 'writeUInt8', function () { return 1; }, null]); + module.exports = { CodeBiasesContent: CodeBiasesContent, PhaseBiasesContent: PhaseBiasesContent, @@ -1074,11 +1235,17 @@ module.exports = { MsgSsrCodeBiases: MsgSsrCodeBiases, 0x05E6: MsgSsrPhaseBiases, MsgSsrPhaseBiases: MsgSsrPhaseBiases, - 0x05FB: MsgSsrStecCorrection, + 0x05FB: MsgSsrStecCorrectionDep, + MsgSsrStecCorrectionDep: MsgSsrStecCorrectionDep, + 0x05FD: MsgSsrStecCorrection, MsgSsrStecCorrection: MsgSsrStecCorrection, 0x05FC: MsgSsrGriddedCorrection, MsgSsrGriddedCorrection: MsgSsrGriddedCorrection, - 0x05F6: MsgSsrTileDefinition, + 0x05FE: MsgSsrGriddedCorrectionBounds, + MsgSsrGriddedCorrectionBounds: MsgSsrGriddedCorrectionBounds, + 0x05F6: MsgSsrTileDefinitionDep, + MsgSsrTileDefinitionDep: MsgSsrTileDefinitionDep, + 0x05F7: MsgSsrTileDefinition, MsgSsrTileDefinition: MsgSsrTileDefinition, SatelliteAPC: SatelliteAPC, 0x0604: MsgSsrSatelliteApc, @@ -1096,4 +1263,10 @@ module.exports = { MsgSsrGriddedCorrectionDepA: MsgSsrGriddedCorrectionDepA, 0x05F5: MsgSsrGridDefinitionDepA, MsgSsrGridDefinitionDepA: MsgSsrGridDefinitionDepA, + 0x05DE: MsgSsrOrbitClockBounds, + MsgSsrOrbitClockBounds: MsgSsrOrbitClockBounds, + 0x05EC: MsgSsrCodePhaseBiasesBounds, + MsgSsrCodePhaseBiasesBounds: MsgSsrCodePhaseBiasesBounds, + 0x05DF: MsgSsrOrbitClockBoundsDegradation, + MsgSsrOrbitClockBoundsDegradation: MsgSsrOrbitClockBoundsDegradation, } \ No newline at end of file diff --git a/jsonschema/MsgGPSLeapSecond.json b/jsonschema/MsgGPSLeapSecond.json new file mode 100644 index 0000000000..041d73c4a0 --- /dev/null +++ b/jsonschema/MsgGPSLeapSecond.json @@ -0,0 +1,24 @@ +{ + "copyright": [ + "Copyright (C) 2019-2021 Swift Navigation Inc.", + "Contact: https://support.swiftnav.com", + "", + "This source is subject to the license found in the file 'LICENSE' which must", + "be be distributed together with this source. All other rights reserved.", + "", + "THIS CODE AND INFORMATION IS PROVIDED 'AS IS' WITHOUT WARRANTY OF ANY KIND,", + "EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED", + "WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE." + ], + "$schema": "http://json-schema.org/draft-06/schema#", + "$id": "#MsgGPSLeapSecond", + "title":"MsgGPSLeapSecond", + "description":"Emulates the GPS CNAV message, reserving bytes for future broadcast of the drift model parameters.\n", + "type": "object", + "properties": { + "stub": {"type": "array", "items": {"type": "integer"}} + }, + "required": [ + "stub" + ] +} \ No newline at end of file diff --git a/jsonschema/MsgItrf.json b/jsonschema/MsgItrf.json new file mode 100644 index 0000000000..a221564875 --- /dev/null +++ b/jsonschema/MsgItrf.json @@ -0,0 +1,24 @@ +{ + "copyright": [ + "Copyright (C) 2019-2021 Swift Navigation Inc.", + "Contact: https://support.swiftnav.com", + "", + "This source is subject to the license found in the file 'LICENSE' which must", + "be be distributed together with this source. All other rights reserved.", + "", + "THIS CODE AND INFORMATION IS PROVIDED 'AS IS' WITHOUT WARRANTY OF ANY KIND,", + "EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED", + "WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE." + ], + "$schema": "http://json-schema.org/draft-06/schema#", + "$id": "#MsgItrf", + "title":"MsgItrf", + "description":"", + "type": "object", + "properties": { + "stub": {"type": "array", "items": {"type": "integer"}} + }, + "required": [ + "stub" + ] +} \ No newline at end of file diff --git a/jsonschema/MsgSsrCodePhaseBiasesBounds.json b/jsonschema/MsgSsrCodePhaseBiasesBounds.json new file mode 100644 index 0000000000..de40de4304 --- /dev/null +++ b/jsonschema/MsgSsrCodePhaseBiasesBounds.json @@ -0,0 +1,24 @@ +{ + "copyright": [ + "Copyright (C) 2019-2021 Swift Navigation Inc.", + "Contact: https://support.swiftnav.com", + "", + "This source is subject to the license found in the file 'LICENSE' which must", + "be be distributed together with this source. All other rights reserved.", + "", + "THIS CODE AND INFORMATION IS PROVIDED 'AS IS' WITHOUT WARRANTY OF ANY KIND,", + "EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED", + "WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE." + ], + "$schema": "http://json-schema.org/draft-06/schema#", + "$id": "#MsgSsrCodePhaseBiasesBounds", + "title":"MsgSsrCodePhaseBiasesBounds", + "description":"", + "type": "object", + "properties": { + "stub": {"type": "array", "items": {"type": "integer"}} + }, + "required": [ + "stub" + ] +} \ No newline at end of file diff --git a/jsonschema/MsgSsrFlagHighLevel.json b/jsonschema/MsgSsrFlagHighLevel.json new file mode 100644 index 0000000000..67edf90f7d --- /dev/null +++ b/jsonschema/MsgSsrFlagHighLevel.json @@ -0,0 +1,24 @@ +{ + "copyright": [ + "Copyright (C) 2019-2021 Swift Navigation Inc.", + "Contact: https://support.swiftnav.com", + "", + "This source is subject to the license found in the file 'LICENSE' which must", + "be be distributed together with this source. All other rights reserved.", + "", + "THIS CODE AND INFORMATION IS PROVIDED 'AS IS' WITHOUT WARRANTY OF ANY KIND,", + "EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED", + "WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE." + ], + "$schema": "http://json-schema.org/draft-06/schema#", + "$id": "#MsgSsrFlagHighLevel", + "title":"MsgSsrFlagHighLevel", + "description":"", + "type": "object", + "properties": { + "stub": {"type": "array", "items": {"type": "integer"}} + }, + "required": [ + "stub" + ] +} \ No newline at end of file diff --git a/jsonschema/MsgSsrFlagIonoGridPointSatLos.json b/jsonschema/MsgSsrFlagIonoGridPointSatLos.json new file mode 100644 index 0000000000..18e05dae6d --- /dev/null +++ b/jsonschema/MsgSsrFlagIonoGridPointSatLos.json @@ -0,0 +1,24 @@ +{ + "copyright": [ + "Copyright (C) 2019-2021 Swift Navigation Inc.", + "Contact: https://support.swiftnav.com", + "", + "This source is subject to the license found in the file 'LICENSE' which must", + "be be distributed together with this source. All other rights reserved.", + "", + "THIS CODE AND INFORMATION IS PROVIDED 'AS IS' WITHOUT WARRANTY OF ANY KIND,", + "EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED", + "WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE." + ], + "$schema": "http://json-schema.org/draft-06/schema#", + "$id": "#MsgSsrFlagIonoGridPointSatLos", + "title":"MsgSsrFlagIonoGridPointSatLos", + "description":"", + "type": "object", + "properties": { + "stub": {"type": "array", "items": {"type": "integer"}} + }, + "required": [ + "stub" + ] +} \ No newline at end of file diff --git a/jsonschema/MsgSsrFlagIonoGridPoints.json b/jsonschema/MsgSsrFlagIonoGridPoints.json new file mode 100644 index 0000000000..3a7d058540 --- /dev/null +++ b/jsonschema/MsgSsrFlagIonoGridPoints.json @@ -0,0 +1,24 @@ +{ + "copyright": [ + "Copyright (C) 2019-2021 Swift Navigation Inc.", + "Contact: https://support.swiftnav.com", + "", + "This source is subject to the license found in the file 'LICENSE' which must", + "be be distributed together with this source. All other rights reserved.", + "", + "THIS CODE AND INFORMATION IS PROVIDED 'AS IS' WITHOUT WARRANTY OF ANY KIND,", + "EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED", + "WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE." + ], + "$schema": "http://json-schema.org/draft-06/schema#", + "$id": "#MsgSsrFlagIonoGridPoints", + "title":"MsgSsrFlagIonoGridPoints", + "description":"", + "type": "object", + "properties": { + "stub": {"type": "array", "items": {"type": "integer"}} + }, + "required": [ + "stub" + ] +} \ No newline at end of file diff --git a/jsonschema/MsgSsrFlagIonoTileSatLos.json b/jsonschema/MsgSsrFlagIonoTileSatLos.json new file mode 100644 index 0000000000..f3f5cd0caf --- /dev/null +++ b/jsonschema/MsgSsrFlagIonoTileSatLos.json @@ -0,0 +1,24 @@ +{ + "copyright": [ + "Copyright (C) 2019-2021 Swift Navigation Inc.", + "Contact: https://support.swiftnav.com", + "", + "This source is subject to the license found in the file 'LICENSE' which must", + "be be distributed together with this source. All other rights reserved.", + "", + "THIS CODE AND INFORMATION IS PROVIDED 'AS IS' WITHOUT WARRANTY OF ANY KIND,", + "EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED", + "WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE." + ], + "$schema": "http://json-schema.org/draft-06/schema#", + "$id": "#MsgSsrFlagIonoTileSatLos", + "title":"MsgSsrFlagIonoTileSatLos", + "description":"", + "type": "object", + "properties": { + "stub": {"type": "array", "items": {"type": "integer"}} + }, + "required": [ + "stub" + ] +} \ No newline at end of file diff --git a/jsonschema/MsgSsrFlagSatellites.json b/jsonschema/MsgSsrFlagSatellites.json new file mode 100644 index 0000000000..5c32c6799d --- /dev/null +++ b/jsonschema/MsgSsrFlagSatellites.json @@ -0,0 +1,24 @@ +{ + "copyright": [ + "Copyright (C) 2019-2021 Swift Navigation Inc.", + "Contact: https://support.swiftnav.com", + "", + "This source is subject to the license found in the file 'LICENSE' which must", + "be be distributed together with this source. All other rights reserved.", + "", + "THIS CODE AND INFORMATION IS PROVIDED 'AS IS' WITHOUT WARRANTY OF ANY KIND,", + "EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED", + "WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE." + ], + "$schema": "http://json-schema.org/draft-06/schema#", + "$id": "#MsgSsrFlagSatellites", + "title":"MsgSsrFlagSatellites", + "description":"", + "type": "object", + "properties": { + "stub": {"type": "array", "items": {"type": "integer"}} + }, + "required": [ + "stub" + ] +} \ No newline at end of file diff --git a/jsonschema/MsgSsrFlagTropoGridPoints.json b/jsonschema/MsgSsrFlagTropoGridPoints.json new file mode 100644 index 0000000000..6883c505d7 --- /dev/null +++ b/jsonschema/MsgSsrFlagTropoGridPoints.json @@ -0,0 +1,24 @@ +{ + "copyright": [ + "Copyright (C) 2019-2021 Swift Navigation Inc.", + "Contact: https://support.swiftnav.com", + "", + "This source is subject to the license found in the file 'LICENSE' which must", + "be be distributed together with this source. All other rights reserved.", + "", + "THIS CODE AND INFORMATION IS PROVIDED 'AS IS' WITHOUT WARRANTY OF ANY KIND,", + "EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED", + "WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE." + ], + "$schema": "http://json-schema.org/draft-06/schema#", + "$id": "#MsgSsrFlagTropoGridPoints", + "title":"MsgSsrFlagTropoGridPoints", + "description":"", + "type": "object", + "properties": { + "stub": {"type": "array", "items": {"type": "integer"}} + }, + "required": [ + "stub" + ] +} \ No newline at end of file diff --git a/jsonschema/MsgSsrGriddedCorrectionBounds.json b/jsonschema/MsgSsrGriddedCorrectionBounds.json new file mode 100644 index 0000000000..db5f675c56 --- /dev/null +++ b/jsonschema/MsgSsrGriddedCorrectionBounds.json @@ -0,0 +1,24 @@ +{ + "copyright": [ + "Copyright (C) 2019-2021 Swift Navigation Inc.", + "Contact: https://support.swiftnav.com", + "", + "This source is subject to the license found in the file 'LICENSE' which must", + "be be distributed together with this source. All other rights reserved.", + "", + "THIS CODE AND INFORMATION IS PROVIDED 'AS IS' WITHOUT WARRANTY OF ANY KIND,", + "EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED", + "WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE." + ], + "$schema": "http://json-schema.org/draft-06/schema#", + "$id": "#MsgSsrGriddedCorrectionBounds", + "title":"MsgSsrGriddedCorrectionBounds", + "description":"", + "type": "object", + "properties": { + "stub": {"type": "array", "items": {"type": "integer"}} + }, + "required": [ + "stub" + ] +} \ No newline at end of file diff --git a/jsonschema/MsgSsrOrbitClockBounds.json b/jsonschema/MsgSsrOrbitClockBounds.json new file mode 100644 index 0000000000..69de75f045 --- /dev/null +++ b/jsonschema/MsgSsrOrbitClockBounds.json @@ -0,0 +1,24 @@ +{ + "copyright": [ + "Copyright (C) 2019-2021 Swift Navigation Inc.", + "Contact: https://support.swiftnav.com", + "", + "This source is subject to the license found in the file 'LICENSE' which must", + "be be distributed together with this source. All other rights reserved.", + "", + "THIS CODE AND INFORMATION IS PROVIDED 'AS IS' WITHOUT WARRANTY OF ANY KIND,", + "EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED", + "WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE." + ], + "$schema": "http://json-schema.org/draft-06/schema#", + "$id": "#MsgSsrOrbitClockBounds", + "title":"MsgSsrOrbitClockBounds", + "description":"", + "type": "object", + "properties": { + "stub": {"type": "array", "items": {"type": "integer"}} + }, + "required": [ + "stub" + ] +} \ No newline at end of file diff --git a/jsonschema/MsgSsrOrbitClockBoundsDegradation.json b/jsonschema/MsgSsrOrbitClockBoundsDegradation.json new file mode 100644 index 0000000000..4826cee480 --- /dev/null +++ b/jsonschema/MsgSsrOrbitClockBoundsDegradation.json @@ -0,0 +1,24 @@ +{ + "copyright": [ + "Copyright (C) 2019-2021 Swift Navigation Inc.", + "Contact: https://support.swiftnav.com", + "", + "This source is subject to the license found in the file 'LICENSE' which must", + "be be distributed together with this source. All other rights reserved.", + "", + "THIS CODE AND INFORMATION IS PROVIDED 'AS IS' WITHOUT WARRANTY OF ANY KIND,", + "EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED", + "WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE." + ], + "$schema": "http://json-schema.org/draft-06/schema#", + "$id": "#MsgSsrOrbitClockBoundsDegradation", + "title":"MsgSsrOrbitClockBoundsDegradation", + "description":"", + "type": "object", + "properties": { + "stub": {"type": "array", "items": {"type": "integer"}} + }, + "required": [ + "stub" + ] +} \ No newline at end of file diff --git a/jsonschema/MsgSsrStecCorrection.json b/jsonschema/MsgSsrStecCorrection.json index c5767fa002..9ed78d4fbd 100644 --- a/jsonschema/MsgSsrStecCorrection.json +++ b/jsonschema/MsgSsrStecCorrection.json @@ -13,14 +13,12 @@ "$schema": "http://json-schema.org/draft-06/schema#", "$id": "#MsgSsrStecCorrection", "title":"MsgSsrStecCorrection", - "description":"The Slant Total Electron Content per space vehicle, given as polynomial approximation for a given tile. This should be combined with the MSG_SSR_GRIDDED_CORRECTION message to get the state space representation of the atmospheric delay.,\n,\nIt is typically equivalent to the QZSS CLAS Sub Type 8 messages.\n", + "description":"", "type": "object", "properties": { - "header": {"$ref": "STECHeader.json"}, - "stec_sat_list": {"type": "array", "items": {"$ref": "STECSatElement.json"}} + "stub": {"type": "array", "items": {"type": "integer"}} }, "required": [ - "header", - "stec_sat_list" + "stub" ] } \ No newline at end of file diff --git a/jsonschema/MsgSsrTileDefinition.json b/jsonschema/MsgSsrTileDefinition.json index c6438bb85e..3bfb141ec1 100644 --- a/jsonschema/MsgSsrTileDefinition.json +++ b/jsonschema/MsgSsrTileDefinition.json @@ -16,25 +16,9 @@ "description":"Provides the correction point coordinates for the atmospheric correction values in the MSG_SSR_STEC_CORRECTION and MSG_SSR_GRIDDED_CORRECTION messages.,\n,\nBased on ETSI TS 137 355 V16.1.0 (LTE Positioning Protocol) information element GNSS-SSR-CorrectionPoints. SBP only supports gridded arrays of correction points, not lists of points.\n", "type": "object", "properties": { - "tile_set_id": {"type": "integer"}, - "tile_id": {"type": "integer"}, - "corner_nw_lat": {"type": "integer"}, - "corner_nw_lon": {"type": "integer"}, - "spacing_lat": {"type": "integer"}, - "spacing_lon": {"type": "integer"}, - "rows": {"type": "integer"}, - "cols": {"type": "integer"}, - "bitmask": {"type": "integer"} + "stub": {"type": "array", "items": {"type": "integer"}} }, "required": [ - "tile_set_id", - "tile_id", - "corner_nw_lat", - "corner_nw_lon", - "spacing_lat", - "spacing_lon", - "rows", - "cols", - "bitmask" + "stub" ] } \ No newline at end of file diff --git a/proto/integrity.proto b/proto/integrity.proto new file mode 100644 index 0000000000..15dd760132 --- /dev/null +++ b/proto/integrity.proto @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +syntax = "proto3"; + +/** Integrity + * + * Integrity flag messages + */ + +package swiftnav.sbp.integrity; + +import "gnss.proto"; + +/** High level integrity flags + * +None + */ +message MsgSsrFlagHighLevel { + repeated uint32 stub = 1; +} + +/** List of satellites which are faulty, per constellation + * +None + */ +message MsgSsrFlagSatellites { + repeated uint32 stub = 1; +} + +/** List of grid points which are faulty + * +None + */ +message MsgSsrFlagTropoGridPoints { + repeated uint32 stub = 1; +} + +/** List of grid points which are faulty + * +None + */ +message MsgSsrFlagIonoGridPoints { + repeated uint32 stub = 1; +} + +/** List of all the LOS which are faulty + * +None + */ +message MsgSsrFlagIonoTileSatLos { + repeated uint32 stub = 1; +} + +/** List of all the grid points to satellite which are faulty + * +None + */ +message MsgSsrFlagIonoGridPointSatLos { + repeated uint32 stub = 1; +} \ No newline at end of file diff --git a/proto/navigation.proto b/proto/navigation.proto index b3acec3287..a18d63d9a2 100644 --- a/proto/navigation.proto +++ b/proto/navigation.proto @@ -647,4 +647,22 @@ message MsgProtectionLevel { sint32 pitch = 19; sint32 heading = 20; uint32 flags = 21; +} + +/** Leap second SBP message. + + * + * Emulates the GPS CNAV message, reserving bytes for future broadcast of the + * drift model parameters. + */ +message MsgGpsLeapSecond { + repeated uint32 stub = 1; +} + +/** Reference Frame Transformation Parameter + * +None + */ +message MsgItrf { + repeated uint32 stub = 1; } \ No newline at end of file diff --git a/proto/ssr.proto b/proto/ssr.proto index 26d56e99e9..d5266e9074 100644 --- a/proto/ssr.proto +++ b/proto/ssr.proto @@ -184,16 +184,10 @@ message MsgSsrPhaseBiases { /** STEC correction polynomial coefficients * - * The Slant Total Electron Content per space vehicle, given as polynomial - * approximation for a given tile. This should be combined with the - * MSG_SSR_GRIDDED_CORRECTION message to get the state space representation of - * the atmospheric delay. - * - * It is typically equivalent to the QZSS CLAS Sub Type 8 messages. +None */ message MsgSsrStecCorrection { - STECHeader header = 1; - repeated STECSatElement stec_sat_list = 2; + repeated uint32 stub = 1; } /** Gridded troposphere and STEC correction residuals @@ -209,6 +203,14 @@ message MsgSsrGriddedCorrection { repeated STECResidual stec_residuals = 4; } +/** Gridded troposhere and STEC correction residuals bounds + * +None + */ +message MsgSsrGriddedCorrectionBounds { + repeated uint32 stub = 1; +} + /** Definition of a SSR atmospheric correction tile. * @@ -221,15 +223,7 @@ message MsgSsrGriddedCorrection { * correction points, not lists of points. */ message MsgSsrTileDefinition { - uint32 tile_set_id = 1; - uint32 tile_id = 2; - sint32 corner_nw_lat = 3; - sint32 corner_nw_lon = 4; - uint32 spacing_lat = 5; - uint32 spacing_lon = 6; - uint32 rows = 7; - uint32 cols = 8; - uint64 bitmask = 9; + repeated uint32 stub = 1; } /** Antenna phase center correction @@ -251,4 +245,28 @@ None */ message MsgSsrSatelliteApc { repeated SatelliteAPC apc = 1; +} + +/** Stubbed version of Combined Orbit and Clock Bound + * +None + */ +message MsgSsrOrbitClockBounds { + repeated uint32 stub = 1; +} + +/** Stubbed version of Combined Code and Phase Biases Bounds + * +None + */ +message MsgSsrCodePhaseBiasesBounds { + repeated uint32 stub = 1; +} + +/** Combined Orbit and Clock Bound Degradation Parameter + * +None + */ +message MsgSsrOrbitClockBoundsDegradation { + repeated uint32 stub = 1; } \ No newline at end of file diff --git a/python/docs/source/spelling_wordlist.txt b/python/docs/source/spelling_wordlist.txt index db53d4f24f..11bd8176da 100644 --- a/python/docs/source/spelling_wordlist.txt +++ b/python/docs/source/spelling_wordlist.txt @@ -1,11 +1,14 @@ 0x00BD AE Acq +BBD +BCD BD Beidou Bestpos Bn Codephase +DF Duro EB FB @@ -16,6 +19,7 @@ IPv InputType Iono Kalman +LoS MiB Navstar Piksi @@ -80,6 +84,7 @@ infofirmware interoperable io iode +iono iterable ith jit diff --git a/python/sbp/integrity.py b/python/sbp/integrity.py new file mode 100644 index 0000000000..aa7c31937e --- /dev/null +++ b/python/sbp/integrity.py @@ -0,0 +1,558 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2021 Swift Navigation Inc. +# Contact: https://support.swiftnav.com +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Integrity flag messages +""" + +import json + +import construct + +from sbp.msg import SBP, SENDER_ID +from sbp.utils import fmt_repr, exclude_fields, walk_json_dict, containerize + +# Automatically generated from piksi/yaml/swiftnav/sbp/integrity.yaml with generate.py. +# Please do not hand edit! + + +SBP_MSG_SSR_FLAG_HIGH_LEVEL = 0x0BB9 +class MsgSsrFlagHighLevel(SBP): + """SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BB9). + + You can have MSG_SSR_FLAG_HIGH_LEVEL inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + stub : array + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'stub' / construct.GreedyRange(construct.Int8ul),) + __slots__ = [ + 'stub', + ] + + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgSsrFlagHighLevel, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgSsrFlagHighLevel, self).__init__() + self.msg_type = SBP_MSG_SSR_FLAG_HIGH_LEVEL + self.sender = kwargs.pop('sender', SENDER_ID) + self.stub = kwargs.pop('stub') + + def __repr__(self): + return fmt_repr(self) + + @staticmethod + def from_json(s): + """Given a JSON-encoded string s, build a message object. + + """ + d = json.loads(s) + return MsgSsrFlagHighLevel.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgSsrFlagHighLevel(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgSsrFlagHighLevel._parser.parse(d) + for n in self.__class__.__slots__: + setattr(self, n, getattr(p, n)) + + def to_binary(self): + """Produce a framed/packed SBP message. + + """ + c = containerize(exclude_fields(self)) + self.payload = MsgSsrFlagHighLevel._parser.build(c) + return self.pack() + + def into_buffer(self, buf, offset): + """Produce a framed/packed SBP message into the provided buffer and offset. + + """ + self.payload = containerize(exclude_fields(self)) + self.parser = MsgSsrFlagHighLevel._parser + self.stream_payload.reset(buf, offset) + return self.pack_into(buf, offset, self._build_payload) + + def to_json_dict(self): + self.to_binary() + d = super( MsgSsrFlagHighLevel, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + +SBP_MSG_SSR_FLAG_SATELLITES = 0x0BBD +class MsgSsrFlagSatellites(SBP): + """SBP class for message MSG_SSR_FLAG_SATELLITES (0x0BBD). + + You can have MSG_SSR_FLAG_SATELLITES inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + stub : array + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'stub' / construct.GreedyRange(construct.Int8ul),) + __slots__ = [ + 'stub', + ] + + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgSsrFlagSatellites, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgSsrFlagSatellites, self).__init__() + self.msg_type = SBP_MSG_SSR_FLAG_SATELLITES + self.sender = kwargs.pop('sender', SENDER_ID) + self.stub = kwargs.pop('stub') + + def __repr__(self): + return fmt_repr(self) + + @staticmethod + def from_json(s): + """Given a JSON-encoded string s, build a message object. + + """ + d = json.loads(s) + return MsgSsrFlagSatellites.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgSsrFlagSatellites(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgSsrFlagSatellites._parser.parse(d) + for n in self.__class__.__slots__: + setattr(self, n, getattr(p, n)) + + def to_binary(self): + """Produce a framed/packed SBP message. + + """ + c = containerize(exclude_fields(self)) + self.payload = MsgSsrFlagSatellites._parser.build(c) + return self.pack() + + def into_buffer(self, buf, offset): + """Produce a framed/packed SBP message into the provided buffer and offset. + + """ + self.payload = containerize(exclude_fields(self)) + self.parser = MsgSsrFlagSatellites._parser + self.stream_payload.reset(buf, offset) + return self.pack_into(buf, offset, self._build_payload) + + def to_json_dict(self): + self.to_binary() + d = super( MsgSsrFlagSatellites, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + +SBP_MSG_SSR_FLAG_TROPO_GRID_POINTS = 0x0BC3 +class MsgSsrFlagTropoGridPoints(SBP): + """SBP class for message MSG_SSR_FLAG_TROPO_GRID_POINTS (0x0BC3). + + You can have MSG_SSR_FLAG_TROPO_GRID_POINTS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + stub : array + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'stub' / construct.GreedyRange(construct.Int8ul),) + __slots__ = [ + 'stub', + ] + + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgSsrFlagTropoGridPoints, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgSsrFlagTropoGridPoints, self).__init__() + self.msg_type = SBP_MSG_SSR_FLAG_TROPO_GRID_POINTS + self.sender = kwargs.pop('sender', SENDER_ID) + self.stub = kwargs.pop('stub') + + def __repr__(self): + return fmt_repr(self) + + @staticmethod + def from_json(s): + """Given a JSON-encoded string s, build a message object. + + """ + d = json.loads(s) + return MsgSsrFlagTropoGridPoints.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgSsrFlagTropoGridPoints(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgSsrFlagTropoGridPoints._parser.parse(d) + for n in self.__class__.__slots__: + setattr(self, n, getattr(p, n)) + + def to_binary(self): + """Produce a framed/packed SBP message. + + """ + c = containerize(exclude_fields(self)) + self.payload = MsgSsrFlagTropoGridPoints._parser.build(c) + return self.pack() + + def into_buffer(self, buf, offset): + """Produce a framed/packed SBP message into the provided buffer and offset. + + """ + self.payload = containerize(exclude_fields(self)) + self.parser = MsgSsrFlagTropoGridPoints._parser + self.stream_payload.reset(buf, offset) + return self.pack_into(buf, offset, self._build_payload) + + def to_json_dict(self): + self.to_binary() + d = super( MsgSsrFlagTropoGridPoints, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + +SBP_MSG_SSR_FLAG_IONO_GRID_POINTS = 0x0BC7 +class MsgSsrFlagIonoGridPoints(SBP): + """SBP class for message MSG_SSR_FLAG_IONO_GRID_POINTS (0x0BC7). + + You can have MSG_SSR_FLAG_IONO_GRID_POINTS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + stub : array + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'stub' / construct.GreedyRange(construct.Int8ul),) + __slots__ = [ + 'stub', + ] + + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgSsrFlagIonoGridPoints, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgSsrFlagIonoGridPoints, self).__init__() + self.msg_type = SBP_MSG_SSR_FLAG_IONO_GRID_POINTS + self.sender = kwargs.pop('sender', SENDER_ID) + self.stub = kwargs.pop('stub') + + def __repr__(self): + return fmt_repr(self) + + @staticmethod + def from_json(s): + """Given a JSON-encoded string s, build a message object. + + """ + d = json.loads(s) + return MsgSsrFlagIonoGridPoints.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgSsrFlagIonoGridPoints(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgSsrFlagIonoGridPoints._parser.parse(d) + for n in self.__class__.__slots__: + setattr(self, n, getattr(p, n)) + + def to_binary(self): + """Produce a framed/packed SBP message. + + """ + c = containerize(exclude_fields(self)) + self.payload = MsgSsrFlagIonoGridPoints._parser.build(c) + return self.pack() + + def into_buffer(self, buf, offset): + """Produce a framed/packed SBP message into the provided buffer and offset. + + """ + self.payload = containerize(exclude_fields(self)) + self.parser = MsgSsrFlagIonoGridPoints._parser + self.stream_payload.reset(buf, offset) + return self.pack_into(buf, offset, self._build_payload) + + def to_json_dict(self): + self.to_binary() + d = super( MsgSsrFlagIonoGridPoints, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + +SBP_MSG_SSR_FLAG_IONO_TILE_SAT_LOS = 0x0BCD +class MsgSsrFlagIonoTileSatLos(SBP): + """SBP class for message MSG_SSR_FLAG_IONO_TILE_SAT_LOS (0x0BCD). + + You can have MSG_SSR_FLAG_IONO_TILE_SAT_LOS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + stub : array + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'stub' / construct.GreedyRange(construct.Int8ul),) + __slots__ = [ + 'stub', + ] + + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgSsrFlagIonoTileSatLos, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgSsrFlagIonoTileSatLos, self).__init__() + self.msg_type = SBP_MSG_SSR_FLAG_IONO_TILE_SAT_LOS + self.sender = kwargs.pop('sender', SENDER_ID) + self.stub = kwargs.pop('stub') + + def __repr__(self): + return fmt_repr(self) + + @staticmethod + def from_json(s): + """Given a JSON-encoded string s, build a message object. + + """ + d = json.loads(s) + return MsgSsrFlagIonoTileSatLos.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgSsrFlagIonoTileSatLos(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgSsrFlagIonoTileSatLos._parser.parse(d) + for n in self.__class__.__slots__: + setattr(self, n, getattr(p, n)) + + def to_binary(self): + """Produce a framed/packed SBP message. + + """ + c = containerize(exclude_fields(self)) + self.payload = MsgSsrFlagIonoTileSatLos._parser.build(c) + return self.pack() + + def into_buffer(self, buf, offset): + """Produce a framed/packed SBP message into the provided buffer and offset. + + """ + self.payload = containerize(exclude_fields(self)) + self.parser = MsgSsrFlagIonoTileSatLos._parser + self.stream_payload.reset(buf, offset) + return self.pack_into(buf, offset, self._build_payload) + + def to_json_dict(self): + self.to_binary() + d = super( MsgSsrFlagIonoTileSatLos, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + +SBP_MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS = 0x0BD1 +class MsgSsrFlagIonoGridPointSatLos(SBP): + """SBP class for message MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS (0x0BD1). + + You can have MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + stub : array + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'stub' / construct.GreedyRange(construct.Int8ul),) + __slots__ = [ + 'stub', + ] + + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgSsrFlagIonoGridPointSatLos, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgSsrFlagIonoGridPointSatLos, self).__init__() + self.msg_type = SBP_MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS + self.sender = kwargs.pop('sender', SENDER_ID) + self.stub = kwargs.pop('stub') + + def __repr__(self): + return fmt_repr(self) + + @staticmethod + def from_json(s): + """Given a JSON-encoded string s, build a message object. + + """ + d = json.loads(s) + return MsgSsrFlagIonoGridPointSatLos.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgSsrFlagIonoGridPointSatLos(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgSsrFlagIonoGridPointSatLos._parser.parse(d) + for n in self.__class__.__slots__: + setattr(self, n, getattr(p, n)) + + def to_binary(self): + """Produce a framed/packed SBP message. + + """ + c = containerize(exclude_fields(self)) + self.payload = MsgSsrFlagIonoGridPointSatLos._parser.build(c) + return self.pack() + + def into_buffer(self, buf, offset): + """Produce a framed/packed SBP message into the provided buffer and offset. + + """ + self.payload = containerize(exclude_fields(self)) + self.parser = MsgSsrFlagIonoGridPointSatLos._parser + self.stream_payload.reset(buf, offset) + return self.pack_into(buf, offset, self._build_payload) + + def to_json_dict(self): + self.to_binary() + d = super( MsgSsrFlagIonoGridPointSatLos, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + + +msg_classes = { + 0x0BB9: MsgSsrFlagHighLevel, + 0x0BBD: MsgSsrFlagSatellites, + 0x0BC3: MsgSsrFlagTropoGridPoints, + 0x0BC7: MsgSsrFlagIonoGridPoints, + 0x0BCD: MsgSsrFlagIonoTileSatLos, + 0x0BD1: MsgSsrFlagIonoGridPointSatLos, +} \ No newline at end of file diff --git a/python/sbp/navigation.py b/python/sbp/navigation.py index 49dad9d458..6cbdab04b8 100755 --- a/python/sbp/navigation.py +++ b/python/sbp/navigation.py @@ -5105,6 +5105,182 @@ def to_json_dict(self): d.update(j) return d +SBP_MSG_GPS_LEAP_SECOND = 0x023A +class MsgGPSLeapSecond(SBP): + """SBP class for message MSG_GPS_LEAP_SECOND (0x023A). + + You can have MSG_GPS_LEAP_SECOND inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Emulates the GPS CNAV message, reserving bytes for future broadcast of the + drift model parameters. + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + stub : array + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'stub' / construct.GreedyRange(construct.Int8ul),) + __slots__ = [ + 'stub', + ] + + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgGPSLeapSecond, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgGPSLeapSecond, self).__init__() + self.msg_type = SBP_MSG_GPS_LEAP_SECOND + self.sender = kwargs.pop('sender', SENDER_ID) + self.stub = kwargs.pop('stub') + + def __repr__(self): + return fmt_repr(self) + + @staticmethod + def from_json(s): + """Given a JSON-encoded string s, build a message object. + + """ + d = json.loads(s) + return MsgGPSLeapSecond.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgGPSLeapSecond(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgGPSLeapSecond._parser.parse(d) + for n in self.__class__.__slots__: + setattr(self, n, getattr(p, n)) + + def to_binary(self): + """Produce a framed/packed SBP message. + + """ + c = containerize(exclude_fields(self)) + self.payload = MsgGPSLeapSecond._parser.build(c) + return self.pack() + + def into_buffer(self, buf, offset): + """Produce a framed/packed SBP message into the provided buffer and offset. + + """ + self.payload = containerize(exclude_fields(self)) + self.parser = MsgGPSLeapSecond._parser + self.stream_payload.reset(buf, offset) + return self.pack_into(buf, offset, self._build_payload) + + def to_json_dict(self): + self.to_binary() + d = super( MsgGPSLeapSecond, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + +SBP_MSG_ITRF = 0x0244 +class MsgItrf(SBP): + """SBP class for message MSG_ITRF (0x0244). + + You can have MSG_ITRF inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + stub : array + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'stub' / construct.GreedyRange(construct.Int8ul),) + __slots__ = [ + 'stub', + ] + + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgItrf, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgItrf, self).__init__() + self.msg_type = SBP_MSG_ITRF + self.sender = kwargs.pop('sender', SENDER_ID) + self.stub = kwargs.pop('stub') + + def __repr__(self): + return fmt_repr(self) + + @staticmethod + def from_json(s): + """Given a JSON-encoded string s, build a message object. + + """ + d = json.loads(s) + return MsgItrf.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgItrf(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgItrf._parser.parse(d) + for n in self.__class__.__slots__: + setattr(self, n, getattr(p, n)) + + def to_binary(self): + """Produce a framed/packed SBP message. + + """ + c = containerize(exclude_fields(self)) + self.payload = MsgItrf._parser.build(c) + return self.pack() + + def into_buffer(self, buf, offset): + """Produce a framed/packed SBP message into the provided buffer and offset. + + """ + self.payload = containerize(exclude_fields(self)) + self.parser = MsgItrf._parser + self.stream_payload.reset(buf, offset) + return self.pack_into(buf, offset, self._build_payload) + + def to_json_dict(self): + self.to_binary() + d = super( MsgItrf, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + msg_classes = { 0x0102: MsgGPSTime, @@ -5145,4 +5321,6 @@ def to_json_dict(self): 0x0207: MsgBaselineHeadingDepA, 0x0216: MsgProtectionLevelDepA, 0x0217: MsgProtectionLevel, + 0x023A: MsgGPSLeapSecond, + 0x0244: MsgItrf, } \ No newline at end of file diff --git a/python/sbp/ssr.py b/python/sbp/ssr.py index b3cba8c0bc..b30096f8f4 100644 --- a/python/sbp/ssr.py +++ b/python/sbp/ssr.py @@ -1079,11 +1079,11 @@ def to_json_dict(self): d.update(j) return d -SBP_MSG_SSR_STEC_CORRECTION = 0x05FB -class MsgSsrStecCorrection(SBP): - """SBP class for message MSG_SSR_STEC_CORRECTION (0x05FB). +SBP_MSG_SSR_STEC_CORRECTION_DEP = 0x05FB +class MsgSsrStecCorrectionDep(SBP): + """SBP class for message MSG_SSR_STEC_CORRECTION_DEP (0x05FB). - You can have MSG_SSR_STEC_CORRECTION inherit its fields directly + You can have MSG_SSR_STEC_CORRECTION_DEP inherit its fields directly from an inherited SBP object, or construct it inline using a dict of its fields. @@ -1115,6 +1115,94 @@ class MsgSsrStecCorrection(SBP): 'stec_sat_list', ] + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgSsrStecCorrectionDep, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgSsrStecCorrectionDep, self).__init__() + self.msg_type = SBP_MSG_SSR_STEC_CORRECTION_DEP + self.sender = kwargs.pop('sender', SENDER_ID) + self.header = kwargs.pop('header') + self.stec_sat_list = kwargs.pop('stec_sat_list') + + def __repr__(self): + return fmt_repr(self) + + @staticmethod + def from_json(s): + """Given a JSON-encoded string s, build a message object. + + """ + d = json.loads(s) + return MsgSsrStecCorrectionDep.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgSsrStecCorrectionDep(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgSsrStecCorrectionDep._parser.parse(d) + for n in self.__class__.__slots__: + setattr(self, n, getattr(p, n)) + + def to_binary(self): + """Produce a framed/packed SBP message. + + """ + c = containerize(exclude_fields(self)) + self.payload = MsgSsrStecCorrectionDep._parser.build(c) + return self.pack() + + def into_buffer(self, buf, offset): + """Produce a framed/packed SBP message into the provided buffer and offset. + + """ + self.payload = containerize(exclude_fields(self)) + self.parser = MsgSsrStecCorrectionDep._parser + self.stream_payload.reset(buf, offset) + return self.pack_into(buf, offset, self._build_payload) + + def to_json_dict(self): + self.to_binary() + d = super( MsgSsrStecCorrectionDep, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + +SBP_MSG_SSR_STEC_CORRECTION = 0x05FD +class MsgSsrStecCorrection(SBP): + """SBP class for message MSG_SSR_STEC_CORRECTION (0x05FD). + + You can have MSG_SSR_STEC_CORRECTION inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + stub : array + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'stub' / construct.GreedyRange(construct.Int8ul),) + __slots__ = [ + 'stub', + ] + def __init__(self, sbp=None, **kwargs): if sbp: super( MsgSsrStecCorrection, @@ -1125,8 +1213,7 @@ def __init__(self, sbp=None, **kwargs): super( MsgSsrStecCorrection, self).__init__() self.msg_type = SBP_MSG_SSR_STEC_CORRECTION self.sender = kwargs.pop('sender', SENDER_ID) - self.header = kwargs.pop('header') - self.stec_sat_list = kwargs.pop('stec_sat_list') + self.stub = kwargs.pop('stub') def __repr__(self): return fmt_repr(self) @@ -1284,17 +1371,104 @@ def to_json_dict(self): d.update(j) return d -SBP_MSG_SSR_TILE_DEFINITION = 0x05F6 -class MsgSsrTileDefinition(SBP): - """SBP class for message MSG_SSR_TILE_DEFINITION (0x05F6). +SBP_MSG_SSR_GRIDDED_CORRECTION_BOUNDS = 0x05FE +class MsgSsrGriddedCorrectionBounds(SBP): + """SBP class for message MSG_SSR_GRIDDED_CORRECTION_BOUNDS (0x05FE). - You can have MSG_SSR_TILE_DEFINITION inherit its fields directly + You can have MSG_SSR_GRIDDED_CORRECTION_BOUNDS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + stub : array + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'stub' / construct.GreedyRange(construct.Int8ul),) + __slots__ = [ + 'stub', + ] + + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgSsrGriddedCorrectionBounds, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgSsrGriddedCorrectionBounds, self).__init__() + self.msg_type = SBP_MSG_SSR_GRIDDED_CORRECTION_BOUNDS + self.sender = kwargs.pop('sender', SENDER_ID) + self.stub = kwargs.pop('stub') + + def __repr__(self): + return fmt_repr(self) + + @staticmethod + def from_json(s): + """Given a JSON-encoded string s, build a message object. + + """ + d = json.loads(s) + return MsgSsrGriddedCorrectionBounds.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgSsrGriddedCorrectionBounds(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgSsrGriddedCorrectionBounds._parser.parse(d) + for n in self.__class__.__slots__: + setattr(self, n, getattr(p, n)) + + def to_binary(self): + """Produce a framed/packed SBP message. + + """ + c = containerize(exclude_fields(self)) + self.payload = MsgSsrGriddedCorrectionBounds._parser.build(c) + return self.pack() + + def into_buffer(self, buf, offset): + """Produce a framed/packed SBP message into the provided buffer and offset. + + """ + self.payload = containerize(exclude_fields(self)) + self.parser = MsgSsrGriddedCorrectionBounds._parser + self.stream_payload.reset(buf, offset) + return self.pack_into(buf, offset, self._build_payload) + + def to_json_dict(self): + self.to_binary() + d = super( MsgSsrGriddedCorrectionBounds, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + +SBP_MSG_SSR_TILE_DEFINITION_DEP = 0x05F6 +class MsgSsrTileDefinitionDep(SBP): + """SBP class for message MSG_SSR_TILE_DEFINITION_DEP (0x05F6). + + You can have MSG_SSR_TILE_DEFINITION_DEP inherit its fields directly from an inherited SBP object, or construct it inline using a dict of its fields. Provides the correction point coordinates for the atmospheric correction - values in the MSG_SSR_STEC_CORRECTION and MSG_SSR_GRIDDED_CORRECTION + values in the MSG_SSR_STEC_CORRECTION_DEP and MSG_SSR_GRIDDED_CORRECTION messages. Based on ETSI TS 137 355 V16.1.0 (LTE Positioning Protocol) information @@ -1388,13 +1562,13 @@ class MsgSsrTileDefinition(SBP): def __init__(self, sbp=None, **kwargs): if sbp: - super( MsgSsrTileDefinition, + super( MsgSsrTileDefinitionDep, self).__init__(sbp.msg_type, sbp.sender, sbp.length, sbp.payload, sbp.crc) self.from_binary(sbp.payload) else: - super( MsgSsrTileDefinition, self).__init__() - self.msg_type = SBP_MSG_SSR_TILE_DEFINITION + super( MsgSsrTileDefinitionDep, self).__init__() + self.msg_type = SBP_MSG_SSR_TILE_DEFINITION_DEP self.sender = kwargs.pop('sender', SENDER_ID) self.tile_set_id = kwargs.pop('tile_set_id') self.tile_id = kwargs.pop('tile_id') @@ -1409,6 +1583,100 @@ def __init__(self, sbp=None, **kwargs): def __repr__(self): return fmt_repr(self) + @staticmethod + def from_json(s): + """Given a JSON-encoded string s, build a message object. + + """ + d = json.loads(s) + return MsgSsrTileDefinitionDep.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgSsrTileDefinitionDep(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgSsrTileDefinitionDep._parser.parse(d) + for n in self.__class__.__slots__: + setattr(self, n, getattr(p, n)) + + def to_binary(self): + """Produce a framed/packed SBP message. + + """ + c = containerize(exclude_fields(self)) + self.payload = MsgSsrTileDefinitionDep._parser.build(c) + return self.pack() + + def into_buffer(self, buf, offset): + """Produce a framed/packed SBP message into the provided buffer and offset. + + """ + self.payload = containerize(exclude_fields(self)) + self.parser = MsgSsrTileDefinitionDep._parser + self.stream_payload.reset(buf, offset) + return self.pack_into(buf, offset, self._build_payload) + + def to_json_dict(self): + self.to_binary() + d = super( MsgSsrTileDefinitionDep, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + +SBP_MSG_SSR_TILE_DEFINITION = 0x05F7 +class MsgSsrTileDefinition(SBP): + """SBP class for message MSG_SSR_TILE_DEFINITION (0x05F7). + + You can have MSG_SSR_TILE_DEFINITION inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Provides the correction point coordinates for the atmospheric correction + values in the MSG_SSR_STEC_CORRECTION and MSG_SSR_GRIDDED_CORRECTION + messages. + + Based on ETSI TS 137 355 V16.1.0 (LTE Positioning Protocol) information + element GNSS-SSR-CorrectionPoints. SBP only supports gridded arrays of + correction points, not lists of points. + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + stub : array + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'stub' / construct.GreedyRange(construct.Int8ul),) + __slots__ = [ + 'stub', + ] + + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgSsrTileDefinition, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgSsrTileDefinition, self).__init__() + self.msg_type = SBP_MSG_SSR_TILE_DEFINITION + self.sender = kwargs.pop('sender', SENDER_ID) + self.stub = kwargs.pop('stub') + + def __repr__(self): + return fmt_repr(self) + @staticmethod def from_json(s): """Given a JSON-encoded string s, build a message object. @@ -2094,18 +2362,285 @@ def to_json_dict(self): d.update(j) return d +SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS = 0x05DE +class MsgSsrOrbitClockBounds(SBP): + """SBP class for message MSG_SSR_ORBIT_CLOCK_BOUNDS (0x05DE). + + You can have MSG_SSR_ORBIT_CLOCK_BOUNDS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + stub : array + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'stub' / construct.GreedyRange(construct.Int8ul),) + __slots__ = [ + 'stub', + ] + + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgSsrOrbitClockBounds, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgSsrOrbitClockBounds, self).__init__() + self.msg_type = SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS + self.sender = kwargs.pop('sender', SENDER_ID) + self.stub = kwargs.pop('stub') + + def __repr__(self): + return fmt_repr(self) + + @staticmethod + def from_json(s): + """Given a JSON-encoded string s, build a message object. + + """ + d = json.loads(s) + return MsgSsrOrbitClockBounds.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgSsrOrbitClockBounds(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgSsrOrbitClockBounds._parser.parse(d) + for n in self.__class__.__slots__: + setattr(self, n, getattr(p, n)) + + def to_binary(self): + """Produce a framed/packed SBP message. + + """ + c = containerize(exclude_fields(self)) + self.payload = MsgSsrOrbitClockBounds._parser.build(c) + return self.pack() + + def into_buffer(self, buf, offset): + """Produce a framed/packed SBP message into the provided buffer and offset. + + """ + self.payload = containerize(exclude_fields(self)) + self.parser = MsgSsrOrbitClockBounds._parser + self.stream_payload.reset(buf, offset) + return self.pack_into(buf, offset, self._build_payload) + + def to_json_dict(self): + self.to_binary() + d = super( MsgSsrOrbitClockBounds, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + +SBP_MSG_SSR_CODE_PHASE_BIASES_BOUNDS = 0x05EC +class MsgSsrCodePhaseBiasesBounds(SBP): + """SBP class for message MSG_SSR_CODE_PHASE_BIASES_BOUNDS (0x05EC). + + You can have MSG_SSR_CODE_PHASE_BIASES_BOUNDS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + stub : array + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'stub' / construct.GreedyRange(construct.Int8ul),) + __slots__ = [ + 'stub', + ] + + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgSsrCodePhaseBiasesBounds, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgSsrCodePhaseBiasesBounds, self).__init__() + self.msg_type = SBP_MSG_SSR_CODE_PHASE_BIASES_BOUNDS + self.sender = kwargs.pop('sender', SENDER_ID) + self.stub = kwargs.pop('stub') + + def __repr__(self): + return fmt_repr(self) + + @staticmethod + def from_json(s): + """Given a JSON-encoded string s, build a message object. + + """ + d = json.loads(s) + return MsgSsrCodePhaseBiasesBounds.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgSsrCodePhaseBiasesBounds(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgSsrCodePhaseBiasesBounds._parser.parse(d) + for n in self.__class__.__slots__: + setattr(self, n, getattr(p, n)) + + def to_binary(self): + """Produce a framed/packed SBP message. + + """ + c = containerize(exclude_fields(self)) + self.payload = MsgSsrCodePhaseBiasesBounds._parser.build(c) + return self.pack() + + def into_buffer(self, buf, offset): + """Produce a framed/packed SBP message into the provided buffer and offset. + + """ + self.payload = containerize(exclude_fields(self)) + self.parser = MsgSsrCodePhaseBiasesBounds._parser + self.stream_payload.reset(buf, offset) + return self.pack_into(buf, offset, self._build_payload) + + def to_json_dict(self): + self.to_binary() + d = super( MsgSsrCodePhaseBiasesBounds, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + +SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION = 0x05DF +class MsgSsrOrbitClockBoundsDegradation(SBP): + """SBP class for message MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION (0x05DF). + + You can have MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + stub : array + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'stub' / construct.GreedyRange(construct.Int8ul),) + __slots__ = [ + 'stub', + ] + + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgSsrOrbitClockBoundsDegradation, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgSsrOrbitClockBoundsDegradation, self).__init__() + self.msg_type = SBP_MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION + self.sender = kwargs.pop('sender', SENDER_ID) + self.stub = kwargs.pop('stub') + + def __repr__(self): + return fmt_repr(self) + + @staticmethod + def from_json(s): + """Given a JSON-encoded string s, build a message object. + + """ + d = json.loads(s) + return MsgSsrOrbitClockBoundsDegradation.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgSsrOrbitClockBoundsDegradation(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgSsrOrbitClockBoundsDegradation._parser.parse(d) + for n in self.__class__.__slots__: + setattr(self, n, getattr(p, n)) + + def to_binary(self): + """Produce a framed/packed SBP message. + + """ + c = containerize(exclude_fields(self)) + self.payload = MsgSsrOrbitClockBoundsDegradation._parser.build(c) + return self.pack() + + def into_buffer(self, buf, offset): + """Produce a framed/packed SBP message into the provided buffer and offset. + + """ + self.payload = containerize(exclude_fields(self)) + self.parser = MsgSsrOrbitClockBoundsDegradation._parser + self.stream_payload.reset(buf, offset) + return self.pack_into(buf, offset, self._build_payload) + + def to_json_dict(self): + self.to_binary() + d = super( MsgSsrOrbitClockBoundsDegradation, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + msg_classes = { 0x05DD: MsgSsrOrbitClock, 0x05E1: MsgSsrCodeBiases, 0x05E6: MsgSsrPhaseBiases, - 0x05FB: MsgSsrStecCorrection, + 0x05FB: MsgSsrStecCorrectionDep, + 0x05FD: MsgSsrStecCorrection, 0x05FC: MsgSsrGriddedCorrection, - 0x05F6: MsgSsrTileDefinition, + 0x05FE: MsgSsrGriddedCorrectionBounds, + 0x05F6: MsgSsrTileDefinitionDep, + 0x05F7: MsgSsrTileDefinition, 0x0604: MsgSsrSatelliteApc, 0x05DC: MsgSsrOrbitClockDepA, 0x05EB: MsgSsrStecCorrectionDepA, 0x05F0: MsgSsrGriddedCorrectionNoStdDepA, 0x05FA: MsgSsrGriddedCorrectionDepA, 0x05F5: MsgSsrGridDefinitionDepA, + 0x05DE: MsgSsrOrbitClockBounds, + 0x05EC: MsgSsrCodePhaseBiasesBounds, + 0x05DF: MsgSsrOrbitClockBoundsDegradation, } \ No newline at end of file diff --git a/python/sbp/table.py b/python/sbp/table.py index f754ce905d..5d2465fa7c 100755 --- a/python/sbp/table.py +++ b/python/sbp/table.py @@ -30,6 +30,7 @@ from . import ext_events as ext_events from . import user as user from . import imu as imu +from . import integrity as integrity from . import mag as mag from . import ndb as ndb from . import vehicle as vehicle @@ -54,6 +55,7 @@ + list(trac.msg_classes.items()) + list(user.msg_classes.items()) + list(imu.msg_classes.items()) + + list(integrity.msg_classes.items()) + list(mag.msg_classes.items()) + list(ext_events.msg_classes.items()) + list(ndb.msg_classes.items()) @@ -116,4 +118,4 @@ def lookup(msg_type, table=_SBP_TABLE): SBP Message class """ - return table.get(msg_type) \ No newline at end of file + return table.get(msg_type) diff --git a/python/tests/sbp/test_table.py b/python/tests/sbp/test_table.py index b2eee6783f..29dff32539 100644 --- a/python/tests/sbp/test_table.py +++ b/python/tests/sbp/test_table.py @@ -24,6 +24,7 @@ from sbp import tracking as trac from sbp import user as user from sbp import imu as imu +from sbp import integrity as integrity from sbp import ext_events as ext_events from sbp import ndb as ndb from sbp import mag as mag @@ -40,7 +41,7 @@ def test_table_count(): Test number of available messages to deserialize. """ - number_of_messages = 205 + number_of_messages = 219 assert len(_SBP_TABLE) == number_of_messages def test_table_unqiue_count(): @@ -61,6 +62,7 @@ def test_table_unqiue_count(): + len(trac.msg_classes) + len(user.msg_classes) + len(imu.msg_classes) + + len(integrity.msg_classes) + len(ext_events.msg_classes) + len(ndb.msg_classes) + len(mag.msg_classes) diff --git a/rust/sbp/src/messages/integrity.rs b/rust/sbp/src/messages/integrity.rs new file mode 100644 index 0000000000..b83208b7f9 --- /dev/null +++ b/rust/sbp/src/messages/integrity.rs @@ -0,0 +1,423 @@ +// Copyright (C) 2015-2021 Swift Navigation Inc. +// Contact: https://support.swiftnav.com +// +// This source is subject to the license found in the file 'LICENSE' which must +// be be distributed together with this source. All other rights reserved. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +//**************************************************************************** +// Automatically generated from yaml/swiftnav/sbp/integrity.yaml +// with generate.py. Please do not hand edit! +//****************************************************************************/ +//! Integrity flag messages +pub use msg_ssr_flag_high_level::MsgSsrFlagHighLevel; +pub use msg_ssr_flag_iono_grid_point_sat_los::MsgSsrFlagIonoGridPointSatLos; +pub use msg_ssr_flag_iono_grid_points::MsgSsrFlagIonoGridPoints; +pub use msg_ssr_flag_iono_tile_sat_los::MsgSsrFlagIonoTileSatLos; +pub use msg_ssr_flag_satellites::MsgSsrFlagSatellites; +pub use msg_ssr_flag_tropo_grid_points::MsgSsrFlagTropoGridPoints; + +pub mod msg_ssr_flag_high_level { + #![allow(unused_imports)] + + use super::*; + use crate::messages::gnss::*; + use crate::messages::lib::*; + /// High level integrity flags + #[cfg_attr(feature = "serde", derive(serde::Serialize))] + #[derive(Debug, Clone)] + pub struct MsgSsrFlagHighLevel { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing))] + pub sender_id: Option, + #[cfg_attr(feature = "serde", serde(rename(serialize = "stub")))] + pub stub: Vec, + } + + impl ConcreteMessage for MsgSsrFlagHighLevel { + const MESSAGE_TYPE: u16 = 3001; + const MESSAGE_NAME: &'static str = "MSG_SSR_FLAG_HIGH_LEVEL"; + } + + impl SbpMessage for MsgSsrFlagHighLevel { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> u16 { + ::MESSAGE_TYPE + } + fn sender_id(&self) -> Option { + self.sender_id + } + fn set_sender_id(&mut self, new_id: u16) { + self.sender_id = Some(new_id); + } + fn encoded_len(&self) -> usize { + WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN + } + } + + impl TryFrom for MsgSsrFlagHighLevel { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgSsrFlagHighLevel(m) => Ok(m), + _ => Err(TryFromSbpError), + } + } + } + + impl WireFormat for MsgSsrFlagHighLevel { + const MIN_LEN: usize = as WireFormat>::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.stub) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.stub, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgSsrFlagHighLevel { + sender_id: None, + stub: WireFormat::parse_unchecked(buf), + } + } + } +} + +pub mod msg_ssr_flag_iono_grid_points { + #![allow(unused_imports)] + + use super::*; + use crate::messages::gnss::*; + use crate::messages::lib::*; + /// List of grid points which are faulty + #[cfg_attr(feature = "serde", derive(serde::Serialize))] + #[derive(Debug, Clone)] + pub struct MsgSsrFlagIonoGridPoints { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing))] + pub sender_id: Option, + #[cfg_attr(feature = "serde", serde(rename(serialize = "stub")))] + pub stub: Vec, + } + + impl ConcreteMessage for MsgSsrFlagIonoGridPoints { + const MESSAGE_TYPE: u16 = 3015; + const MESSAGE_NAME: &'static str = "MSG_SSR_FLAG_IONO_GRID_POINTS"; + } + + impl SbpMessage for MsgSsrFlagIonoGridPoints { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> u16 { + ::MESSAGE_TYPE + } + fn sender_id(&self) -> Option { + self.sender_id + } + fn set_sender_id(&mut self, new_id: u16) { + self.sender_id = Some(new_id); + } + fn encoded_len(&self) -> usize { + WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN + } + } + + impl TryFrom for MsgSsrFlagIonoGridPoints { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgSsrFlagIonoGridPoints(m) => Ok(m), + _ => Err(TryFromSbpError), + } + } + } + + impl WireFormat for MsgSsrFlagIonoGridPoints { + const MIN_LEN: usize = as WireFormat>::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.stub) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.stub, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgSsrFlagIonoGridPoints { + sender_id: None, + stub: WireFormat::parse_unchecked(buf), + } + } + } +} + +pub mod msg_ssr_flag_iono_grid_point_sat_los { + #![allow(unused_imports)] + + use super::*; + use crate::messages::gnss::*; + use crate::messages::lib::*; + /// List of all the grid points to satellite which are faulty + #[cfg_attr(feature = "serde", derive(serde::Serialize))] + #[derive(Debug, Clone)] + pub struct MsgSsrFlagIonoGridPointSatLos { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing))] + pub sender_id: Option, + #[cfg_attr(feature = "serde", serde(rename(serialize = "stub")))] + pub stub: Vec, + } + + impl ConcreteMessage for MsgSsrFlagIonoGridPointSatLos { + const MESSAGE_TYPE: u16 = 3025; + const MESSAGE_NAME: &'static str = "MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS"; + } + + impl SbpMessage for MsgSsrFlagIonoGridPointSatLos { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> u16 { + ::MESSAGE_TYPE + } + fn sender_id(&self) -> Option { + self.sender_id + } + fn set_sender_id(&mut self, new_id: u16) { + self.sender_id = Some(new_id); + } + fn encoded_len(&self) -> usize { + WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN + } + } + + impl TryFrom for MsgSsrFlagIonoGridPointSatLos { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgSsrFlagIonoGridPointSatLos(m) => Ok(m), + _ => Err(TryFromSbpError), + } + } + } + + impl WireFormat for MsgSsrFlagIonoGridPointSatLos { + const MIN_LEN: usize = as WireFormat>::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.stub) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.stub, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgSsrFlagIonoGridPointSatLos { + sender_id: None, + stub: WireFormat::parse_unchecked(buf), + } + } + } +} + +pub mod msg_ssr_flag_iono_tile_sat_los { + #![allow(unused_imports)] + + use super::*; + use crate::messages::gnss::*; + use crate::messages::lib::*; + /// List of all the LOS which are faulty + #[cfg_attr(feature = "serde", derive(serde::Serialize))] + #[derive(Debug, Clone)] + pub struct MsgSsrFlagIonoTileSatLos { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing))] + pub sender_id: Option, + #[cfg_attr(feature = "serde", serde(rename(serialize = "stub")))] + pub stub: Vec, + } + + impl ConcreteMessage for MsgSsrFlagIonoTileSatLos { + const MESSAGE_TYPE: u16 = 3021; + const MESSAGE_NAME: &'static str = "MSG_SSR_FLAG_IONO_TILE_SAT_LOS"; + } + + impl SbpMessage for MsgSsrFlagIonoTileSatLos { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> u16 { + ::MESSAGE_TYPE + } + fn sender_id(&self) -> Option { + self.sender_id + } + fn set_sender_id(&mut self, new_id: u16) { + self.sender_id = Some(new_id); + } + fn encoded_len(&self) -> usize { + WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN + } + } + + impl TryFrom for MsgSsrFlagIonoTileSatLos { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgSsrFlagIonoTileSatLos(m) => Ok(m), + _ => Err(TryFromSbpError), + } + } + } + + impl WireFormat for MsgSsrFlagIonoTileSatLos { + const MIN_LEN: usize = as WireFormat>::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.stub) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.stub, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgSsrFlagIonoTileSatLos { + sender_id: None, + stub: WireFormat::parse_unchecked(buf), + } + } + } +} + +pub mod msg_ssr_flag_satellites { + #![allow(unused_imports)] + + use super::*; + use crate::messages::gnss::*; + use crate::messages::lib::*; + /// List of satellites which are faulty, per constellation + #[cfg_attr(feature = "serde", derive(serde::Serialize))] + #[derive(Debug, Clone)] + pub struct MsgSsrFlagSatellites { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing))] + pub sender_id: Option, + #[cfg_attr(feature = "serde", serde(rename(serialize = "stub")))] + pub stub: Vec, + } + + impl ConcreteMessage for MsgSsrFlagSatellites { + const MESSAGE_TYPE: u16 = 3005; + const MESSAGE_NAME: &'static str = "MSG_SSR_FLAG_SATELLITES"; + } + + impl SbpMessage for MsgSsrFlagSatellites { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> u16 { + ::MESSAGE_TYPE + } + fn sender_id(&self) -> Option { + self.sender_id + } + fn set_sender_id(&mut self, new_id: u16) { + self.sender_id = Some(new_id); + } + fn encoded_len(&self) -> usize { + WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN + } + } + + impl TryFrom for MsgSsrFlagSatellites { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgSsrFlagSatellites(m) => Ok(m), + _ => Err(TryFromSbpError), + } + } + } + + impl WireFormat for MsgSsrFlagSatellites { + const MIN_LEN: usize = as WireFormat>::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.stub) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.stub, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgSsrFlagSatellites { + sender_id: None, + stub: WireFormat::parse_unchecked(buf), + } + } + } +} + +pub mod msg_ssr_flag_tropo_grid_points { + #![allow(unused_imports)] + + use super::*; + use crate::messages::gnss::*; + use crate::messages::lib::*; + /// List of grid points which are faulty + #[cfg_attr(feature = "serde", derive(serde::Serialize))] + #[derive(Debug, Clone)] + pub struct MsgSsrFlagTropoGridPoints { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing))] + pub sender_id: Option, + #[cfg_attr(feature = "serde", serde(rename(serialize = "stub")))] + pub stub: Vec, + } + + impl ConcreteMessage for MsgSsrFlagTropoGridPoints { + const MESSAGE_TYPE: u16 = 3011; + const MESSAGE_NAME: &'static str = "MSG_SSR_FLAG_TROPO_GRID_POINTS"; + } + + impl SbpMessage for MsgSsrFlagTropoGridPoints { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> u16 { + ::MESSAGE_TYPE + } + fn sender_id(&self) -> Option { + self.sender_id + } + fn set_sender_id(&mut self, new_id: u16) { + self.sender_id = Some(new_id); + } + fn encoded_len(&self) -> usize { + WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN + } + } + + impl TryFrom for MsgSsrFlagTropoGridPoints { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgSsrFlagTropoGridPoints(m) => Ok(m), + _ => Err(TryFromSbpError), + } + } + } + + impl WireFormat for MsgSsrFlagTropoGridPoints { + const MIN_LEN: usize = as WireFormat>::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.stub) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.stub, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgSsrFlagTropoGridPoints { + sender_id: None, + stub: WireFormat::parse_unchecked(buf), + } + } + } +} diff --git a/rust/sbp/src/messages/mod.rs b/rust/sbp/src/messages/mod.rs index 90684dd580..358ef12b49 100644 --- a/rust/sbp/src/messages/mod.rs +++ b/rust/sbp/src/messages/mod.rs @@ -15,6 +15,7 @@ pub mod file_io; pub mod flash; pub mod gnss; pub mod imu; +pub mod integrity; pub mod linux; pub mod logging; pub mod mag; @@ -66,6 +67,12 @@ use self::flash::msg_stm_unique_id_req::MsgStmUniqueIdReq; use self::flash::msg_stm_unique_id_resp::MsgStmUniqueIdResp; use self::imu::msg_imu_aux::MsgImuAux; use self::imu::msg_imu_raw::MsgImuRaw; +use self::integrity::msg_ssr_flag_high_level::MsgSsrFlagHighLevel; +use self::integrity::msg_ssr_flag_iono_grid_point_sat_los::MsgSsrFlagIonoGridPointSatLos; +use self::integrity::msg_ssr_flag_iono_grid_points::MsgSsrFlagIonoGridPoints; +use self::integrity::msg_ssr_flag_iono_tile_sat_los::MsgSsrFlagIonoTileSatLos; +use self::integrity::msg_ssr_flag_satellites::MsgSsrFlagSatellites; +use self::integrity::msg_ssr_flag_tropo_grid_points::MsgSsrFlagTropoGridPoints; use self::linux::msg_linux_cpu_state::MsgLinuxCpuState; use self::linux::msg_linux_cpu_state_dep_a::MsgLinuxCpuStateDepA; use self::linux::msg_linux_mem_state::MsgLinuxMemState; @@ -89,9 +96,11 @@ use self::navigation::msg_baseline_ned::MsgBaselineNed; use self::navigation::msg_baseline_ned_dep_a::MsgBaselineNedDepA; use self::navigation::msg_dops::MsgDops; use self::navigation::msg_dops_dep_a::MsgDopsDepA; +use self::navigation::msg_gps_leap_second::MsgGpsLeapSecond; use self::navigation::msg_gps_time::MsgGpsTime; use self::navigation::msg_gps_time_dep_a::MsgGpsTimeDepA; use self::navigation::msg_gps_time_gnss::MsgGpsTimeGnss; +use self::navigation::msg_itrf::MsgItrf; use self::navigation::msg_pos_ecef::MsgPosEcef; use self::navigation::msg_pos_ecef_cov::MsgPosEcefCov; use self::navigation::msg_pos_ecef_cov_gnss::MsgPosEcefCovGnss; @@ -201,17 +210,23 @@ use self::settings::msg_settings_write_resp::MsgSettingsWriteResp; use self::solution_meta::msg_soln_meta::MsgSolnMeta; use self::solution_meta::msg_soln_meta_dep_a::MsgSolnMetaDepA; use self::ssr::msg_ssr_code_biases::MsgSsrCodeBiases; +use self::ssr::msg_ssr_code_phase_biases_bounds::MsgSsrCodePhaseBiasesBounds; use self::ssr::msg_ssr_grid_definition_dep_a::MsgSsrGridDefinitionDepA; use self::ssr::msg_ssr_gridded_correction::MsgSsrGriddedCorrection; +use self::ssr::msg_ssr_gridded_correction_bounds::MsgSsrGriddedCorrectionBounds; use self::ssr::msg_ssr_gridded_correction_dep_a::MsgSsrGriddedCorrectionDepA; use self::ssr::msg_ssr_gridded_correction_no_std_dep_a::MsgSsrGriddedCorrectionNoStdDepA; use self::ssr::msg_ssr_orbit_clock::MsgSsrOrbitClock; +use self::ssr::msg_ssr_orbit_clock_bounds::MsgSsrOrbitClockBounds; +use self::ssr::msg_ssr_orbit_clock_bounds_degradation::MsgSsrOrbitClockBoundsDegradation; use self::ssr::msg_ssr_orbit_clock_dep_a::MsgSsrOrbitClockDepA; use self::ssr::msg_ssr_phase_biases::MsgSsrPhaseBiases; use self::ssr::msg_ssr_satellite_apc::MsgSsrSatelliteApc; use self::ssr::msg_ssr_stec_correction::MsgSsrStecCorrection; +use self::ssr::msg_ssr_stec_correction_dep::MsgSsrStecCorrectionDep; use self::ssr::msg_ssr_stec_correction_dep_a::MsgSsrStecCorrectionDepA; use self::ssr::msg_ssr_tile_definition::MsgSsrTileDefinition; +use self::ssr::msg_ssr_tile_definition_dep::MsgSsrTileDefinitionDep; use self::system::msg_csac_telemetry::MsgCsacTelemetry; use self::system::msg_csac_telemetry_labels::MsgCsacTelemetryLabels; use self::system::msg_dgnss_status::MsgDgnssStatus; @@ -636,6 +651,10 @@ pub enum Sbp { MsgPosEcefCovGnss(MsgPosEcefCovGnss), /// GNSS-only Velocity in ECEF MsgVelEcefCovGnss(MsgVelEcefCovGnss), + /// Leap second SBP message. + MsgGpsLeapSecond(MsgGpsLeapSecond), + /// Reference Frame Transformation Parameter + MsgItrf(MsgItrf), /// Navigation DataBase Event MsgNdbEvent(MsgNdbEvent), /// Plaintext logging messages with levels @@ -646,24 +665,36 @@ pub enum Sbp { MsgSsrOrbitClockDepA(MsgSsrOrbitClockDepA), /// Precise orbit and clock correction MsgSsrOrbitClock(MsgSsrOrbitClock), + /// Stubbed version of Combined Orbit and Clock Bound + MsgSsrOrbitClockBounds(MsgSsrOrbitClockBounds), + /// Combined Orbit and Clock Bound Degradation Parameter + MsgSsrOrbitClockBoundsDegradation(MsgSsrOrbitClockBoundsDegradation), /// Precise code biases correction MsgSsrCodeBiases(MsgSsrCodeBiases), /// Precise phase biases correction MsgSsrPhaseBiases(MsgSsrPhaseBiases), /// Deprecated MsgSsrStecCorrectionDepA(MsgSsrStecCorrectionDepA), + /// Stubbed version of Combined Code and Phase Biases Bounds + MsgSsrCodePhaseBiasesBounds(MsgSsrCodePhaseBiasesBounds), /// Deprecated MsgSsrGriddedCorrectionNoStdDepA(MsgSsrGriddedCorrectionNoStdDepA), /// Deprecated MsgSsrGridDefinitionDepA(MsgSsrGridDefinitionDepA), /// Definition of a SSR atmospheric correction tile. + MsgSsrTileDefinitionDep(MsgSsrTileDefinitionDep), + /// Definition of a SSR atmospheric correction tile. MsgSsrTileDefinition(MsgSsrTileDefinition), /// Deprecated MsgSsrGriddedCorrectionDepA(MsgSsrGriddedCorrectionDepA), /// STEC correction polynomial coefficients - MsgSsrStecCorrection(MsgSsrStecCorrection), + MsgSsrStecCorrectionDep(MsgSsrStecCorrectionDep), /// Gridded troposphere and STEC correction residuals MsgSsrGriddedCorrection(MsgSsrGriddedCorrection), + /// STEC correction polynomial coefficients + MsgSsrStecCorrection(MsgSsrStecCorrection), + /// Gridded troposhere and STEC correction residuals bounds + MsgSsrGriddedCorrectionBounds(MsgSsrGriddedCorrectionBounds), /// Satellite antenna phase center corrections MsgSsrSatelliteApc(MsgSsrSatelliteApc), /// OSR corrections @@ -680,6 +711,18 @@ pub enum Sbp { MsgOdometry(MsgOdometry), /// Accumulated wheeltick count message MsgWheeltick(MsgWheeltick), + /// High level integrity flags + MsgSsrFlagHighLevel(MsgSsrFlagHighLevel), + /// List of satellites which are faulty, per constellation + MsgSsrFlagSatellites(MsgSsrFlagSatellites), + /// List of grid points which are faulty + MsgSsrFlagTropoGridPoints(MsgSsrFlagTropoGridPoints), + /// List of grid points which are faulty + MsgSsrFlagIonoGridPoints(MsgSsrFlagIonoGridPoints), + /// List of all the LOS which are faulty + MsgSsrFlagIonoTileSatLos(MsgSsrFlagIonoTileSatLos), + /// List of all the grid points to satellite which are faulty + MsgSsrFlagIonoGridPointSatLos(MsgSsrFlagIonoGridPointSatLos), /// Request advice on the optimal configuration for FileIO MsgFileioConfigReq(MsgFileioConfigReq), /// Response with advice on the optimal configuration for FileIO. @@ -1540,6 +1583,16 @@ impl Sbp { msg.set_sender_id(frame.sender_id); Ok(Sbp::MsgVelEcefCovGnss(msg)) } + MsgGpsLeapSecond::MESSAGE_TYPE => { + let mut msg = MsgGpsLeapSecond::parse(&mut frame.payload)?; + msg.set_sender_id(frame.sender_id); + Ok(Sbp::MsgGpsLeapSecond(msg)) + } + MsgItrf::MESSAGE_TYPE => { + let mut msg = MsgItrf::parse(&mut frame.payload)?; + msg.set_sender_id(frame.sender_id); + Ok(Sbp::MsgItrf(msg)) + } MsgNdbEvent::MESSAGE_TYPE => { let mut msg = MsgNdbEvent::parse(&mut frame.payload)?; msg.set_sender_id(frame.sender_id); @@ -1565,6 +1618,16 @@ impl Sbp { msg.set_sender_id(frame.sender_id); Ok(Sbp::MsgSsrOrbitClock(msg)) } + MsgSsrOrbitClockBounds::MESSAGE_TYPE => { + let mut msg = MsgSsrOrbitClockBounds::parse(&mut frame.payload)?; + msg.set_sender_id(frame.sender_id); + Ok(Sbp::MsgSsrOrbitClockBounds(msg)) + } + MsgSsrOrbitClockBoundsDegradation::MESSAGE_TYPE => { + let mut msg = MsgSsrOrbitClockBoundsDegradation::parse(&mut frame.payload)?; + msg.set_sender_id(frame.sender_id); + Ok(Sbp::MsgSsrOrbitClockBoundsDegradation(msg)) + } MsgSsrCodeBiases::MESSAGE_TYPE => { let mut msg = MsgSsrCodeBiases::parse(&mut frame.payload)?; msg.set_sender_id(frame.sender_id); @@ -1580,6 +1643,11 @@ impl Sbp { msg.set_sender_id(frame.sender_id); Ok(Sbp::MsgSsrStecCorrectionDepA(msg)) } + MsgSsrCodePhaseBiasesBounds::MESSAGE_TYPE => { + let mut msg = MsgSsrCodePhaseBiasesBounds::parse(&mut frame.payload)?; + msg.set_sender_id(frame.sender_id); + Ok(Sbp::MsgSsrCodePhaseBiasesBounds(msg)) + } MsgSsrGriddedCorrectionNoStdDepA::MESSAGE_TYPE => { let mut msg = MsgSsrGriddedCorrectionNoStdDepA::parse(&mut frame.payload)?; msg.set_sender_id(frame.sender_id); @@ -1590,6 +1658,11 @@ impl Sbp { msg.set_sender_id(frame.sender_id); Ok(Sbp::MsgSsrGridDefinitionDepA(msg)) } + MsgSsrTileDefinitionDep::MESSAGE_TYPE => { + let mut msg = MsgSsrTileDefinitionDep::parse(&mut frame.payload)?; + msg.set_sender_id(frame.sender_id); + Ok(Sbp::MsgSsrTileDefinitionDep(msg)) + } MsgSsrTileDefinition::MESSAGE_TYPE => { let mut msg = MsgSsrTileDefinition::parse(&mut frame.payload)?; msg.set_sender_id(frame.sender_id); @@ -1600,16 +1673,26 @@ impl Sbp { msg.set_sender_id(frame.sender_id); Ok(Sbp::MsgSsrGriddedCorrectionDepA(msg)) } - MsgSsrStecCorrection::MESSAGE_TYPE => { - let mut msg = MsgSsrStecCorrection::parse(&mut frame.payload)?; + MsgSsrStecCorrectionDep::MESSAGE_TYPE => { + let mut msg = MsgSsrStecCorrectionDep::parse(&mut frame.payload)?; msg.set_sender_id(frame.sender_id); - Ok(Sbp::MsgSsrStecCorrection(msg)) + Ok(Sbp::MsgSsrStecCorrectionDep(msg)) } MsgSsrGriddedCorrection::MESSAGE_TYPE => { let mut msg = MsgSsrGriddedCorrection::parse(&mut frame.payload)?; msg.set_sender_id(frame.sender_id); Ok(Sbp::MsgSsrGriddedCorrection(msg)) } + MsgSsrStecCorrection::MESSAGE_TYPE => { + let mut msg = MsgSsrStecCorrection::parse(&mut frame.payload)?; + msg.set_sender_id(frame.sender_id); + Ok(Sbp::MsgSsrStecCorrection(msg)) + } + MsgSsrGriddedCorrectionBounds::MESSAGE_TYPE => { + let mut msg = MsgSsrGriddedCorrectionBounds::parse(&mut frame.payload)?; + msg.set_sender_id(frame.sender_id); + Ok(Sbp::MsgSsrGriddedCorrectionBounds(msg)) + } MsgSsrSatelliteApc::MESSAGE_TYPE => { let mut msg = MsgSsrSatelliteApc::parse(&mut frame.payload)?; msg.set_sender_id(frame.sender_id); @@ -1650,6 +1733,36 @@ impl Sbp { msg.set_sender_id(frame.sender_id); Ok(Sbp::MsgWheeltick(msg)) } + MsgSsrFlagHighLevel::MESSAGE_TYPE => { + let mut msg = MsgSsrFlagHighLevel::parse(&mut frame.payload)?; + msg.set_sender_id(frame.sender_id); + Ok(Sbp::MsgSsrFlagHighLevel(msg)) + } + MsgSsrFlagSatellites::MESSAGE_TYPE => { + let mut msg = MsgSsrFlagSatellites::parse(&mut frame.payload)?; + msg.set_sender_id(frame.sender_id); + Ok(Sbp::MsgSsrFlagSatellites(msg)) + } + MsgSsrFlagTropoGridPoints::MESSAGE_TYPE => { + let mut msg = MsgSsrFlagTropoGridPoints::parse(&mut frame.payload)?; + msg.set_sender_id(frame.sender_id); + Ok(Sbp::MsgSsrFlagTropoGridPoints(msg)) + } + MsgSsrFlagIonoGridPoints::MESSAGE_TYPE => { + let mut msg = MsgSsrFlagIonoGridPoints::parse(&mut frame.payload)?; + msg.set_sender_id(frame.sender_id); + Ok(Sbp::MsgSsrFlagIonoGridPoints(msg)) + } + MsgSsrFlagIonoTileSatLos::MESSAGE_TYPE => { + let mut msg = MsgSsrFlagIonoTileSatLos::parse(&mut frame.payload)?; + msg.set_sender_id(frame.sender_id); + Ok(Sbp::MsgSsrFlagIonoTileSatLos(msg)) + } + MsgSsrFlagIonoGridPointSatLos::MESSAGE_TYPE => { + let mut msg = MsgSsrFlagIonoGridPointSatLos::parse(&mut frame.payload)?; + msg.set_sender_id(frame.sender_id); + Ok(Sbp::MsgSsrFlagIonoGridPointSatLos(msg)) + } MsgFileioConfigReq::MESSAGE_TYPE => { let mut msg = MsgFileioConfigReq::parse(&mut frame.payload)?; msg.set_sender_id(frame.sender_id); @@ -1961,20 +2074,28 @@ impl SbpMessage for Sbp { Sbp::MsgVelNedCovGnss(msg) => msg.message_name(), Sbp::MsgPosEcefCovGnss(msg) => msg.message_name(), Sbp::MsgVelEcefCovGnss(msg) => msg.message_name(), + Sbp::MsgGpsLeapSecond(msg) => msg.message_name(), + Sbp::MsgItrf(msg) => msg.message_name(), Sbp::MsgNdbEvent(msg) => msg.message_name(), Sbp::MsgLog(msg) => msg.message_name(), Sbp::MsgFwd(msg) => msg.message_name(), Sbp::MsgSsrOrbitClockDepA(msg) => msg.message_name(), Sbp::MsgSsrOrbitClock(msg) => msg.message_name(), + Sbp::MsgSsrOrbitClockBounds(msg) => msg.message_name(), + Sbp::MsgSsrOrbitClockBoundsDegradation(msg) => msg.message_name(), Sbp::MsgSsrCodeBiases(msg) => msg.message_name(), Sbp::MsgSsrPhaseBiases(msg) => msg.message_name(), Sbp::MsgSsrStecCorrectionDepA(msg) => msg.message_name(), + Sbp::MsgSsrCodePhaseBiasesBounds(msg) => msg.message_name(), Sbp::MsgSsrGriddedCorrectionNoStdDepA(msg) => msg.message_name(), Sbp::MsgSsrGridDefinitionDepA(msg) => msg.message_name(), + Sbp::MsgSsrTileDefinitionDep(msg) => msg.message_name(), Sbp::MsgSsrTileDefinition(msg) => msg.message_name(), Sbp::MsgSsrGriddedCorrectionDepA(msg) => msg.message_name(), - Sbp::MsgSsrStecCorrection(msg) => msg.message_name(), + Sbp::MsgSsrStecCorrectionDep(msg) => msg.message_name(), Sbp::MsgSsrGriddedCorrection(msg) => msg.message_name(), + Sbp::MsgSsrStecCorrection(msg) => msg.message_name(), + Sbp::MsgSsrGriddedCorrectionBounds(msg) => msg.message_name(), Sbp::MsgSsrSatelliteApc(msg) => msg.message_name(), Sbp::MsgOsr(msg) => msg.message_name(), Sbp::MsgUserData(msg) => msg.message_name(), @@ -1983,6 +2104,12 @@ impl SbpMessage for Sbp { Sbp::MsgMagRaw(msg) => msg.message_name(), Sbp::MsgOdometry(msg) => msg.message_name(), Sbp::MsgWheeltick(msg) => msg.message_name(), + Sbp::MsgSsrFlagHighLevel(msg) => msg.message_name(), + Sbp::MsgSsrFlagSatellites(msg) => msg.message_name(), + Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.message_name(), + Sbp::MsgSsrFlagIonoGridPoints(msg) => msg.message_name(), + Sbp::MsgSsrFlagIonoTileSatLos(msg) => msg.message_name(), + Sbp::MsgSsrFlagIonoGridPointSatLos(msg) => msg.message_name(), Sbp::MsgFileioConfigReq(msg) => msg.message_name(), Sbp::MsgFileioConfigResp(msg) => msg.message_name(), Sbp::MsgSbasRaw(msg) => msg.message_name(), @@ -2172,20 +2299,28 @@ impl SbpMessage for Sbp { Sbp::MsgVelNedCovGnss(msg) => msg.message_type(), Sbp::MsgPosEcefCovGnss(msg) => msg.message_type(), Sbp::MsgVelEcefCovGnss(msg) => msg.message_type(), + Sbp::MsgGpsLeapSecond(msg) => msg.message_type(), + Sbp::MsgItrf(msg) => msg.message_type(), Sbp::MsgNdbEvent(msg) => msg.message_type(), Sbp::MsgLog(msg) => msg.message_type(), Sbp::MsgFwd(msg) => msg.message_type(), Sbp::MsgSsrOrbitClockDepA(msg) => msg.message_type(), Sbp::MsgSsrOrbitClock(msg) => msg.message_type(), + Sbp::MsgSsrOrbitClockBounds(msg) => msg.message_type(), + Sbp::MsgSsrOrbitClockBoundsDegradation(msg) => msg.message_type(), Sbp::MsgSsrCodeBiases(msg) => msg.message_type(), Sbp::MsgSsrPhaseBiases(msg) => msg.message_type(), Sbp::MsgSsrStecCorrectionDepA(msg) => msg.message_type(), + Sbp::MsgSsrCodePhaseBiasesBounds(msg) => msg.message_type(), Sbp::MsgSsrGriddedCorrectionNoStdDepA(msg) => msg.message_type(), Sbp::MsgSsrGridDefinitionDepA(msg) => msg.message_type(), + Sbp::MsgSsrTileDefinitionDep(msg) => msg.message_type(), Sbp::MsgSsrTileDefinition(msg) => msg.message_type(), Sbp::MsgSsrGriddedCorrectionDepA(msg) => msg.message_type(), - Sbp::MsgSsrStecCorrection(msg) => msg.message_type(), + Sbp::MsgSsrStecCorrectionDep(msg) => msg.message_type(), Sbp::MsgSsrGriddedCorrection(msg) => msg.message_type(), + Sbp::MsgSsrStecCorrection(msg) => msg.message_type(), + Sbp::MsgSsrGriddedCorrectionBounds(msg) => msg.message_type(), Sbp::MsgSsrSatelliteApc(msg) => msg.message_type(), Sbp::MsgOsr(msg) => msg.message_type(), Sbp::MsgUserData(msg) => msg.message_type(), @@ -2194,6 +2329,12 @@ impl SbpMessage for Sbp { Sbp::MsgMagRaw(msg) => msg.message_type(), Sbp::MsgOdometry(msg) => msg.message_type(), Sbp::MsgWheeltick(msg) => msg.message_type(), + Sbp::MsgSsrFlagHighLevel(msg) => msg.message_type(), + Sbp::MsgSsrFlagSatellites(msg) => msg.message_type(), + Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.message_type(), + Sbp::MsgSsrFlagIonoGridPoints(msg) => msg.message_type(), + Sbp::MsgSsrFlagIonoTileSatLos(msg) => msg.message_type(), + Sbp::MsgSsrFlagIonoGridPointSatLos(msg) => msg.message_type(), Sbp::MsgFileioConfigReq(msg) => msg.message_type(), Sbp::MsgFileioConfigResp(msg) => msg.message_type(), Sbp::MsgSbasRaw(msg) => msg.message_type(), @@ -2383,20 +2524,28 @@ impl SbpMessage for Sbp { Sbp::MsgVelNedCovGnss(msg) => msg.sender_id(), Sbp::MsgPosEcefCovGnss(msg) => msg.sender_id(), Sbp::MsgVelEcefCovGnss(msg) => msg.sender_id(), + Sbp::MsgGpsLeapSecond(msg) => msg.sender_id(), + Sbp::MsgItrf(msg) => msg.sender_id(), Sbp::MsgNdbEvent(msg) => msg.sender_id(), Sbp::MsgLog(msg) => msg.sender_id(), Sbp::MsgFwd(msg) => msg.sender_id(), Sbp::MsgSsrOrbitClockDepA(msg) => msg.sender_id(), Sbp::MsgSsrOrbitClock(msg) => msg.sender_id(), + Sbp::MsgSsrOrbitClockBounds(msg) => msg.sender_id(), + Sbp::MsgSsrOrbitClockBoundsDegradation(msg) => msg.sender_id(), Sbp::MsgSsrCodeBiases(msg) => msg.sender_id(), Sbp::MsgSsrPhaseBiases(msg) => msg.sender_id(), Sbp::MsgSsrStecCorrectionDepA(msg) => msg.sender_id(), + Sbp::MsgSsrCodePhaseBiasesBounds(msg) => msg.sender_id(), Sbp::MsgSsrGriddedCorrectionNoStdDepA(msg) => msg.sender_id(), Sbp::MsgSsrGridDefinitionDepA(msg) => msg.sender_id(), + Sbp::MsgSsrTileDefinitionDep(msg) => msg.sender_id(), Sbp::MsgSsrTileDefinition(msg) => msg.sender_id(), Sbp::MsgSsrGriddedCorrectionDepA(msg) => msg.sender_id(), - Sbp::MsgSsrStecCorrection(msg) => msg.sender_id(), + Sbp::MsgSsrStecCorrectionDep(msg) => msg.sender_id(), Sbp::MsgSsrGriddedCorrection(msg) => msg.sender_id(), + Sbp::MsgSsrStecCorrection(msg) => msg.sender_id(), + Sbp::MsgSsrGriddedCorrectionBounds(msg) => msg.sender_id(), Sbp::MsgSsrSatelliteApc(msg) => msg.sender_id(), Sbp::MsgOsr(msg) => msg.sender_id(), Sbp::MsgUserData(msg) => msg.sender_id(), @@ -2405,6 +2554,12 @@ impl SbpMessage for Sbp { Sbp::MsgMagRaw(msg) => msg.sender_id(), Sbp::MsgOdometry(msg) => msg.sender_id(), Sbp::MsgWheeltick(msg) => msg.sender_id(), + Sbp::MsgSsrFlagHighLevel(msg) => msg.sender_id(), + Sbp::MsgSsrFlagSatellites(msg) => msg.sender_id(), + Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.sender_id(), + Sbp::MsgSsrFlagIonoGridPoints(msg) => msg.sender_id(), + Sbp::MsgSsrFlagIonoTileSatLos(msg) => msg.sender_id(), + Sbp::MsgSsrFlagIonoGridPointSatLos(msg) => msg.sender_id(), Sbp::MsgFileioConfigReq(msg) => msg.sender_id(), Sbp::MsgFileioConfigResp(msg) => msg.sender_id(), Sbp::MsgSbasRaw(msg) => msg.sender_id(), @@ -2594,20 +2749,28 @@ impl SbpMessage for Sbp { Sbp::MsgVelNedCovGnss(msg) => msg.set_sender_id(new_id), Sbp::MsgPosEcefCovGnss(msg) => msg.set_sender_id(new_id), Sbp::MsgVelEcefCovGnss(msg) => msg.set_sender_id(new_id), + Sbp::MsgGpsLeapSecond(msg) => msg.set_sender_id(new_id), + Sbp::MsgItrf(msg) => msg.set_sender_id(new_id), Sbp::MsgNdbEvent(msg) => msg.set_sender_id(new_id), Sbp::MsgLog(msg) => msg.set_sender_id(new_id), Sbp::MsgFwd(msg) => msg.set_sender_id(new_id), Sbp::MsgSsrOrbitClockDepA(msg) => msg.set_sender_id(new_id), Sbp::MsgSsrOrbitClock(msg) => msg.set_sender_id(new_id), + Sbp::MsgSsrOrbitClockBounds(msg) => msg.set_sender_id(new_id), + Sbp::MsgSsrOrbitClockBoundsDegradation(msg) => msg.set_sender_id(new_id), Sbp::MsgSsrCodeBiases(msg) => msg.set_sender_id(new_id), Sbp::MsgSsrPhaseBiases(msg) => msg.set_sender_id(new_id), Sbp::MsgSsrStecCorrectionDepA(msg) => msg.set_sender_id(new_id), + Sbp::MsgSsrCodePhaseBiasesBounds(msg) => msg.set_sender_id(new_id), Sbp::MsgSsrGriddedCorrectionNoStdDepA(msg) => msg.set_sender_id(new_id), Sbp::MsgSsrGridDefinitionDepA(msg) => msg.set_sender_id(new_id), + Sbp::MsgSsrTileDefinitionDep(msg) => msg.set_sender_id(new_id), Sbp::MsgSsrTileDefinition(msg) => msg.set_sender_id(new_id), Sbp::MsgSsrGriddedCorrectionDepA(msg) => msg.set_sender_id(new_id), - Sbp::MsgSsrStecCorrection(msg) => msg.set_sender_id(new_id), + Sbp::MsgSsrStecCorrectionDep(msg) => msg.set_sender_id(new_id), Sbp::MsgSsrGriddedCorrection(msg) => msg.set_sender_id(new_id), + Sbp::MsgSsrStecCorrection(msg) => msg.set_sender_id(new_id), + Sbp::MsgSsrGriddedCorrectionBounds(msg) => msg.set_sender_id(new_id), Sbp::MsgSsrSatelliteApc(msg) => msg.set_sender_id(new_id), Sbp::MsgOsr(msg) => msg.set_sender_id(new_id), Sbp::MsgUserData(msg) => msg.set_sender_id(new_id), @@ -2616,6 +2779,12 @@ impl SbpMessage for Sbp { Sbp::MsgMagRaw(msg) => msg.set_sender_id(new_id), Sbp::MsgOdometry(msg) => msg.set_sender_id(new_id), Sbp::MsgWheeltick(msg) => msg.set_sender_id(new_id), + Sbp::MsgSsrFlagHighLevel(msg) => msg.set_sender_id(new_id), + Sbp::MsgSsrFlagSatellites(msg) => msg.set_sender_id(new_id), + Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.set_sender_id(new_id), + Sbp::MsgSsrFlagIonoGridPoints(msg) => msg.set_sender_id(new_id), + Sbp::MsgSsrFlagIonoTileSatLos(msg) => msg.set_sender_id(new_id), + Sbp::MsgSsrFlagIonoGridPointSatLos(msg) => msg.set_sender_id(new_id), Sbp::MsgFileioConfigReq(msg) => msg.set_sender_id(new_id), Sbp::MsgFileioConfigResp(msg) => msg.set_sender_id(new_id), Sbp::MsgSbasRaw(msg) => msg.set_sender_id(new_id), @@ -2805,20 +2974,28 @@ impl SbpMessage for Sbp { Sbp::MsgVelNedCovGnss(msg) => msg.encoded_len(), Sbp::MsgPosEcefCovGnss(msg) => msg.encoded_len(), Sbp::MsgVelEcefCovGnss(msg) => msg.encoded_len(), + Sbp::MsgGpsLeapSecond(msg) => msg.encoded_len(), + Sbp::MsgItrf(msg) => msg.encoded_len(), Sbp::MsgNdbEvent(msg) => msg.encoded_len(), Sbp::MsgLog(msg) => msg.encoded_len(), Sbp::MsgFwd(msg) => msg.encoded_len(), Sbp::MsgSsrOrbitClockDepA(msg) => msg.encoded_len(), Sbp::MsgSsrOrbitClock(msg) => msg.encoded_len(), + Sbp::MsgSsrOrbitClockBounds(msg) => msg.encoded_len(), + Sbp::MsgSsrOrbitClockBoundsDegradation(msg) => msg.encoded_len(), Sbp::MsgSsrCodeBiases(msg) => msg.encoded_len(), Sbp::MsgSsrPhaseBiases(msg) => msg.encoded_len(), Sbp::MsgSsrStecCorrectionDepA(msg) => msg.encoded_len(), + Sbp::MsgSsrCodePhaseBiasesBounds(msg) => msg.encoded_len(), Sbp::MsgSsrGriddedCorrectionNoStdDepA(msg) => msg.encoded_len(), Sbp::MsgSsrGridDefinitionDepA(msg) => msg.encoded_len(), + Sbp::MsgSsrTileDefinitionDep(msg) => msg.encoded_len(), Sbp::MsgSsrTileDefinition(msg) => msg.encoded_len(), Sbp::MsgSsrGriddedCorrectionDepA(msg) => msg.encoded_len(), - Sbp::MsgSsrStecCorrection(msg) => msg.encoded_len(), + Sbp::MsgSsrStecCorrectionDep(msg) => msg.encoded_len(), Sbp::MsgSsrGriddedCorrection(msg) => msg.encoded_len(), + Sbp::MsgSsrStecCorrection(msg) => msg.encoded_len(), + Sbp::MsgSsrGriddedCorrectionBounds(msg) => msg.encoded_len(), Sbp::MsgSsrSatelliteApc(msg) => msg.encoded_len(), Sbp::MsgOsr(msg) => msg.encoded_len(), Sbp::MsgUserData(msg) => msg.encoded_len(), @@ -2827,6 +3004,12 @@ impl SbpMessage for Sbp { Sbp::MsgMagRaw(msg) => msg.encoded_len(), Sbp::MsgOdometry(msg) => msg.encoded_len(), Sbp::MsgWheeltick(msg) => msg.encoded_len(), + Sbp::MsgSsrFlagHighLevel(msg) => msg.encoded_len(), + Sbp::MsgSsrFlagSatellites(msg) => msg.encoded_len(), + Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.encoded_len(), + Sbp::MsgSsrFlagIonoGridPoints(msg) => msg.encoded_len(), + Sbp::MsgSsrFlagIonoTileSatLos(msg) => msg.encoded_len(), + Sbp::MsgSsrFlagIonoGridPointSatLos(msg) => msg.encoded_len(), Sbp::MsgFileioConfigReq(msg) => msg.encoded_len(), Sbp::MsgFileioConfigResp(msg) => msg.encoded_len(), Sbp::MsgSbasRaw(msg) => msg.encoded_len(), @@ -3019,20 +3202,28 @@ impl SbpMessage for Sbp { Sbp::MsgVelNedCovGnss(msg) => msg.gps_time(), Sbp::MsgPosEcefCovGnss(msg) => msg.gps_time(), Sbp::MsgVelEcefCovGnss(msg) => msg.gps_time(), + Sbp::MsgGpsLeapSecond(msg) => msg.gps_time(), + Sbp::MsgItrf(msg) => msg.gps_time(), Sbp::MsgNdbEvent(msg) => msg.gps_time(), Sbp::MsgLog(msg) => msg.gps_time(), Sbp::MsgFwd(msg) => msg.gps_time(), Sbp::MsgSsrOrbitClockDepA(msg) => msg.gps_time(), Sbp::MsgSsrOrbitClock(msg) => msg.gps_time(), + Sbp::MsgSsrOrbitClockBounds(msg) => msg.gps_time(), + Sbp::MsgSsrOrbitClockBoundsDegradation(msg) => msg.gps_time(), Sbp::MsgSsrCodeBiases(msg) => msg.gps_time(), Sbp::MsgSsrPhaseBiases(msg) => msg.gps_time(), Sbp::MsgSsrStecCorrectionDepA(msg) => msg.gps_time(), + Sbp::MsgSsrCodePhaseBiasesBounds(msg) => msg.gps_time(), Sbp::MsgSsrGriddedCorrectionNoStdDepA(msg) => msg.gps_time(), Sbp::MsgSsrGridDefinitionDepA(msg) => msg.gps_time(), + Sbp::MsgSsrTileDefinitionDep(msg) => msg.gps_time(), Sbp::MsgSsrTileDefinition(msg) => msg.gps_time(), Sbp::MsgSsrGriddedCorrectionDepA(msg) => msg.gps_time(), - Sbp::MsgSsrStecCorrection(msg) => msg.gps_time(), + Sbp::MsgSsrStecCorrectionDep(msg) => msg.gps_time(), Sbp::MsgSsrGriddedCorrection(msg) => msg.gps_time(), + Sbp::MsgSsrStecCorrection(msg) => msg.gps_time(), + Sbp::MsgSsrGriddedCorrectionBounds(msg) => msg.gps_time(), Sbp::MsgSsrSatelliteApc(msg) => msg.gps_time(), Sbp::MsgOsr(msg) => msg.gps_time(), Sbp::MsgUserData(msg) => msg.gps_time(), @@ -3041,6 +3232,12 @@ impl SbpMessage for Sbp { Sbp::MsgMagRaw(msg) => msg.gps_time(), Sbp::MsgOdometry(msg) => msg.gps_time(), Sbp::MsgWheeltick(msg) => msg.gps_time(), + Sbp::MsgSsrFlagHighLevel(msg) => msg.gps_time(), + Sbp::MsgSsrFlagSatellites(msg) => msg.gps_time(), + Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.gps_time(), + Sbp::MsgSsrFlagIonoGridPoints(msg) => msg.gps_time(), + Sbp::MsgSsrFlagIonoTileSatLos(msg) => msg.gps_time(), + Sbp::MsgSsrFlagIonoGridPointSatLos(msg) => msg.gps_time(), Sbp::MsgFileioConfigReq(msg) => msg.gps_time(), Sbp::MsgFileioConfigResp(msg) => msg.gps_time(), Sbp::MsgSbasRaw(msg) => msg.gps_time(), @@ -3238,20 +3435,28 @@ impl WireFormat for Sbp { Sbp::MsgVelNedCovGnss(msg) => WireFormat::write(msg, buf), Sbp::MsgPosEcefCovGnss(msg) => WireFormat::write(msg, buf), Sbp::MsgVelEcefCovGnss(msg) => WireFormat::write(msg, buf), + Sbp::MsgGpsLeapSecond(msg) => WireFormat::write(msg, buf), + Sbp::MsgItrf(msg) => WireFormat::write(msg, buf), Sbp::MsgNdbEvent(msg) => WireFormat::write(msg, buf), Sbp::MsgLog(msg) => WireFormat::write(msg, buf), Sbp::MsgFwd(msg) => WireFormat::write(msg, buf), Sbp::MsgSsrOrbitClockDepA(msg) => WireFormat::write(msg, buf), Sbp::MsgSsrOrbitClock(msg) => WireFormat::write(msg, buf), + Sbp::MsgSsrOrbitClockBounds(msg) => WireFormat::write(msg, buf), + Sbp::MsgSsrOrbitClockBoundsDegradation(msg) => WireFormat::write(msg, buf), Sbp::MsgSsrCodeBiases(msg) => WireFormat::write(msg, buf), Sbp::MsgSsrPhaseBiases(msg) => WireFormat::write(msg, buf), Sbp::MsgSsrStecCorrectionDepA(msg) => WireFormat::write(msg, buf), + Sbp::MsgSsrCodePhaseBiasesBounds(msg) => WireFormat::write(msg, buf), Sbp::MsgSsrGriddedCorrectionNoStdDepA(msg) => WireFormat::write(msg, buf), Sbp::MsgSsrGridDefinitionDepA(msg) => WireFormat::write(msg, buf), + Sbp::MsgSsrTileDefinitionDep(msg) => WireFormat::write(msg, buf), Sbp::MsgSsrTileDefinition(msg) => WireFormat::write(msg, buf), Sbp::MsgSsrGriddedCorrectionDepA(msg) => WireFormat::write(msg, buf), - Sbp::MsgSsrStecCorrection(msg) => WireFormat::write(msg, buf), + Sbp::MsgSsrStecCorrectionDep(msg) => WireFormat::write(msg, buf), Sbp::MsgSsrGriddedCorrection(msg) => WireFormat::write(msg, buf), + Sbp::MsgSsrStecCorrection(msg) => WireFormat::write(msg, buf), + Sbp::MsgSsrGriddedCorrectionBounds(msg) => WireFormat::write(msg, buf), Sbp::MsgSsrSatelliteApc(msg) => WireFormat::write(msg, buf), Sbp::MsgOsr(msg) => WireFormat::write(msg, buf), Sbp::MsgUserData(msg) => WireFormat::write(msg, buf), @@ -3260,6 +3465,12 @@ impl WireFormat for Sbp { Sbp::MsgMagRaw(msg) => WireFormat::write(msg, buf), Sbp::MsgOdometry(msg) => WireFormat::write(msg, buf), Sbp::MsgWheeltick(msg) => WireFormat::write(msg, buf), + Sbp::MsgSsrFlagHighLevel(msg) => WireFormat::write(msg, buf), + Sbp::MsgSsrFlagSatellites(msg) => WireFormat::write(msg, buf), + Sbp::MsgSsrFlagTropoGridPoints(msg) => WireFormat::write(msg, buf), + Sbp::MsgSsrFlagIonoGridPoints(msg) => WireFormat::write(msg, buf), + Sbp::MsgSsrFlagIonoTileSatLos(msg) => WireFormat::write(msg, buf), + Sbp::MsgSsrFlagIonoGridPointSatLos(msg) => WireFormat::write(msg, buf), Sbp::MsgFileioConfigReq(msg) => WireFormat::write(msg, buf), Sbp::MsgFileioConfigResp(msg) => WireFormat::write(msg, buf), Sbp::MsgSbasRaw(msg) => WireFormat::write(msg, buf), @@ -3449,20 +3660,28 @@ impl WireFormat for Sbp { Sbp::MsgVelNedCovGnss(msg) => WireFormat::len(msg), Sbp::MsgPosEcefCovGnss(msg) => WireFormat::len(msg), Sbp::MsgVelEcefCovGnss(msg) => WireFormat::len(msg), + Sbp::MsgGpsLeapSecond(msg) => WireFormat::len(msg), + Sbp::MsgItrf(msg) => WireFormat::len(msg), Sbp::MsgNdbEvent(msg) => WireFormat::len(msg), Sbp::MsgLog(msg) => WireFormat::len(msg), Sbp::MsgFwd(msg) => WireFormat::len(msg), Sbp::MsgSsrOrbitClockDepA(msg) => WireFormat::len(msg), Sbp::MsgSsrOrbitClock(msg) => WireFormat::len(msg), + Sbp::MsgSsrOrbitClockBounds(msg) => WireFormat::len(msg), + Sbp::MsgSsrOrbitClockBoundsDegradation(msg) => WireFormat::len(msg), Sbp::MsgSsrCodeBiases(msg) => WireFormat::len(msg), Sbp::MsgSsrPhaseBiases(msg) => WireFormat::len(msg), Sbp::MsgSsrStecCorrectionDepA(msg) => WireFormat::len(msg), + Sbp::MsgSsrCodePhaseBiasesBounds(msg) => WireFormat::len(msg), Sbp::MsgSsrGriddedCorrectionNoStdDepA(msg) => WireFormat::len(msg), Sbp::MsgSsrGridDefinitionDepA(msg) => WireFormat::len(msg), + Sbp::MsgSsrTileDefinitionDep(msg) => WireFormat::len(msg), Sbp::MsgSsrTileDefinition(msg) => WireFormat::len(msg), Sbp::MsgSsrGriddedCorrectionDepA(msg) => WireFormat::len(msg), - Sbp::MsgSsrStecCorrection(msg) => WireFormat::len(msg), + Sbp::MsgSsrStecCorrectionDep(msg) => WireFormat::len(msg), Sbp::MsgSsrGriddedCorrection(msg) => WireFormat::len(msg), + Sbp::MsgSsrStecCorrection(msg) => WireFormat::len(msg), + Sbp::MsgSsrGriddedCorrectionBounds(msg) => WireFormat::len(msg), Sbp::MsgSsrSatelliteApc(msg) => WireFormat::len(msg), Sbp::MsgOsr(msg) => WireFormat::len(msg), Sbp::MsgUserData(msg) => WireFormat::len(msg), @@ -3471,6 +3690,12 @@ impl WireFormat for Sbp { Sbp::MsgMagRaw(msg) => WireFormat::len(msg), Sbp::MsgOdometry(msg) => WireFormat::len(msg), Sbp::MsgWheeltick(msg) => WireFormat::len(msg), + Sbp::MsgSsrFlagHighLevel(msg) => WireFormat::len(msg), + Sbp::MsgSsrFlagSatellites(msg) => WireFormat::len(msg), + Sbp::MsgSsrFlagTropoGridPoints(msg) => WireFormat::len(msg), + Sbp::MsgSsrFlagIonoGridPoints(msg) => WireFormat::len(msg), + Sbp::MsgSsrFlagIonoTileSatLos(msg) => WireFormat::len(msg), + Sbp::MsgSsrFlagIonoGridPointSatLos(msg) => WireFormat::len(msg), Sbp::MsgFileioConfigReq(msg) => WireFormat::len(msg), Sbp::MsgFileioConfigResp(msg) => WireFormat::len(msg), Sbp::MsgSbasRaw(msg) => WireFormat::len(msg), @@ -4429,6 +4654,18 @@ impl From for Sbp { } } +impl From for Sbp { + fn from(msg: MsgGpsLeapSecond) -> Self { + Sbp::MsgGpsLeapSecond(msg) + } +} + +impl From for Sbp { + fn from(msg: MsgItrf) -> Self { + Sbp::MsgItrf(msg) + } +} + impl From for Sbp { fn from(msg: MsgNdbEvent) -> Self { Sbp::MsgNdbEvent(msg) @@ -4459,6 +4696,18 @@ impl From for Sbp { } } +impl From for Sbp { + fn from(msg: MsgSsrOrbitClockBounds) -> Self { + Sbp::MsgSsrOrbitClockBounds(msg) + } +} + +impl From for Sbp { + fn from(msg: MsgSsrOrbitClockBoundsDegradation) -> Self { + Sbp::MsgSsrOrbitClockBoundsDegradation(msg) + } +} + impl From for Sbp { fn from(msg: MsgSsrCodeBiases) -> Self { Sbp::MsgSsrCodeBiases(msg) @@ -4477,6 +4726,12 @@ impl From for Sbp { } } +impl From for Sbp { + fn from(msg: MsgSsrCodePhaseBiasesBounds) -> Self { + Sbp::MsgSsrCodePhaseBiasesBounds(msg) + } +} + impl From for Sbp { fn from(msg: MsgSsrGriddedCorrectionNoStdDepA) -> Self { Sbp::MsgSsrGriddedCorrectionNoStdDepA(msg) @@ -4489,6 +4744,12 @@ impl From for Sbp { } } +impl From for Sbp { + fn from(msg: MsgSsrTileDefinitionDep) -> Self { + Sbp::MsgSsrTileDefinitionDep(msg) + } +} + impl From for Sbp { fn from(msg: MsgSsrTileDefinition) -> Self { Sbp::MsgSsrTileDefinition(msg) @@ -4501,9 +4762,9 @@ impl From for Sbp { } } -impl From for Sbp { - fn from(msg: MsgSsrStecCorrection) -> Self { - Sbp::MsgSsrStecCorrection(msg) +impl From for Sbp { + fn from(msg: MsgSsrStecCorrectionDep) -> Self { + Sbp::MsgSsrStecCorrectionDep(msg) } } @@ -4513,6 +4774,18 @@ impl From for Sbp { } } +impl From for Sbp { + fn from(msg: MsgSsrStecCorrection) -> Self { + Sbp::MsgSsrStecCorrection(msg) + } +} + +impl From for Sbp { + fn from(msg: MsgSsrGriddedCorrectionBounds) -> Self { + Sbp::MsgSsrGriddedCorrectionBounds(msg) + } +} + impl From for Sbp { fn from(msg: MsgSsrSatelliteApc) -> Self { Sbp::MsgSsrSatelliteApc(msg) @@ -4561,6 +4834,42 @@ impl From for Sbp { } } +impl From for Sbp { + fn from(msg: MsgSsrFlagHighLevel) -> Self { + Sbp::MsgSsrFlagHighLevel(msg) + } +} + +impl From for Sbp { + fn from(msg: MsgSsrFlagSatellites) -> Self { + Sbp::MsgSsrFlagSatellites(msg) + } +} + +impl From for Sbp { + fn from(msg: MsgSsrFlagTropoGridPoints) -> Self { + Sbp::MsgSsrFlagTropoGridPoints(msg) + } +} + +impl From for Sbp { + fn from(msg: MsgSsrFlagIonoGridPoints) -> Self { + Sbp::MsgSsrFlagIonoGridPoints(msg) + } +} + +impl From for Sbp { + fn from(msg: MsgSsrFlagIonoTileSatLos) -> Self { + Sbp::MsgSsrFlagIonoTileSatLos(msg) + } +} + +impl From for Sbp { + fn from(msg: MsgSsrFlagIonoGridPointSatLos) -> Self { + Sbp::MsgSsrFlagIonoGridPointSatLos(msg) + } +} + impl From for Sbp { fn from(msg: MsgFileioConfigReq) -> Self { Sbp::MsgFileioConfigReq(msg) diff --git a/rust/sbp/src/messages/navigation.rs b/rust/sbp/src/messages/navigation.rs index 222db5c4ca..40c0598f78 100644 --- a/rust/sbp/src/messages/navigation.rs +++ b/rust/sbp/src/messages/navigation.rs @@ -45,9 +45,11 @@ pub use msg_baseline_ned::MsgBaselineNed; pub use msg_baseline_ned_dep_a::MsgBaselineNedDepA; pub use msg_dops::MsgDops; pub use msg_dops_dep_a::MsgDopsDepA; +pub use msg_gps_leap_second::MsgGpsLeapSecond; pub use msg_gps_time::MsgGpsTime; pub use msg_gps_time_dep_a::MsgGpsTimeDepA; pub use msg_gps_time_gnss::MsgGpsTimeGnss; +pub use msg_itrf::MsgItrf; pub use msg_pos_ecef::MsgPosEcef; pub use msg_pos_ecef_cov::MsgPosEcefCov; pub use msg_pos_ecef_cov_gnss::MsgPosEcefCovGnss; @@ -1684,6 +1686,78 @@ pub mod msg_dops_dep_a { } } +pub mod msg_gps_leap_second { + #![allow(unused_imports)] + + use super::*; + use crate::messages::lib::*; + + /// Leap second SBP message. + + /// + /// Emulates the GPS CNAV message, reserving bytes for future broadcast of the + /// drift model parameters. + /// + #[cfg_attr(feature = "serde", derive(serde::Serialize))] + #[derive(Debug, Clone)] + pub struct MsgGpsLeapSecond { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing))] + pub sender_id: Option, + #[cfg_attr(feature = "serde", serde(rename(serialize = "stub")))] + pub stub: Vec, + } + + impl ConcreteMessage for MsgGpsLeapSecond { + const MESSAGE_TYPE: u16 = 570; + const MESSAGE_NAME: &'static str = "MSG_GPS_LEAP_SECOND"; + } + + impl SbpMessage for MsgGpsLeapSecond { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> u16 { + ::MESSAGE_TYPE + } + fn sender_id(&self) -> Option { + self.sender_id + } + fn set_sender_id(&mut self, new_id: u16) { + self.sender_id = Some(new_id); + } + fn encoded_len(&self) -> usize { + WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN + } + } + + impl TryFrom for MsgGpsLeapSecond { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgGpsLeapSecond(m) => Ok(m), + _ => Err(TryFromSbpError), + } + } + } + + impl WireFormat for MsgGpsLeapSecond { + const MIN_LEN: usize = as WireFormat>::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.stub) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.stub, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgGpsLeapSecond { + sender_id: None, + stub: WireFormat::parse_unchecked(buf), + } + } + } +} + pub mod msg_gps_time { #![allow(unused_imports)] @@ -2137,6 +2211,72 @@ pub mod msg_gps_time_gnss { } } +pub mod msg_itrf { + #![allow(unused_imports)] + + use super::*; + use crate::messages::lib::*; + /// Reference Frame Transformation Parameter + #[cfg_attr(feature = "serde", derive(serde::Serialize))] + #[derive(Debug, Clone)] + pub struct MsgItrf { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing))] + pub sender_id: Option, + #[cfg_attr(feature = "serde", serde(rename(serialize = "stub")))] + pub stub: Vec, + } + + impl ConcreteMessage for MsgItrf { + const MESSAGE_TYPE: u16 = 580; + const MESSAGE_NAME: &'static str = "MSG_ITRF"; + } + + impl SbpMessage for MsgItrf { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> u16 { + ::MESSAGE_TYPE + } + fn sender_id(&self) -> Option { + self.sender_id + } + fn set_sender_id(&mut self, new_id: u16) { + self.sender_id = Some(new_id); + } + fn encoded_len(&self) -> usize { + WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN + } + } + + impl TryFrom for MsgItrf { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgItrf(m) => Ok(m), + _ => Err(TryFromSbpError), + } + } + } + + impl WireFormat for MsgItrf { + const MIN_LEN: usize = as WireFormat>::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.stub) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.stub, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgItrf { + sender_id: None, + stub: WireFormat::parse_unchecked(buf), + } + } + } +} + pub mod msg_pos_ecef { #![allow(unused_imports)] diff --git a/rust/sbp/src/messages/ssr.rs b/rust/sbp/src/messages/ssr.rs index 7999b09fce..b354ad9e88 100644 --- a/rust/sbp/src/messages/ssr.rs +++ b/rust/sbp/src/messages/ssr.rs @@ -18,17 +18,23 @@ pub use grid_definition_header_dep_a::GridDefinitionHeaderDepA; pub use gridded_correction_header::GriddedCorrectionHeader; pub use gridded_correction_header_dep_a::GriddedCorrectionHeaderDepA; pub use msg_ssr_code_biases::MsgSsrCodeBiases; +pub use msg_ssr_code_phase_biases_bounds::MsgSsrCodePhaseBiasesBounds; pub use msg_ssr_grid_definition_dep_a::MsgSsrGridDefinitionDepA; pub use msg_ssr_gridded_correction::MsgSsrGriddedCorrection; +pub use msg_ssr_gridded_correction_bounds::MsgSsrGriddedCorrectionBounds; pub use msg_ssr_gridded_correction_dep_a::MsgSsrGriddedCorrectionDepA; pub use msg_ssr_gridded_correction_no_std_dep_a::MsgSsrGriddedCorrectionNoStdDepA; pub use msg_ssr_orbit_clock::MsgSsrOrbitClock; +pub use msg_ssr_orbit_clock_bounds::MsgSsrOrbitClockBounds; +pub use msg_ssr_orbit_clock_bounds_degradation::MsgSsrOrbitClockBoundsDegradation; pub use msg_ssr_orbit_clock_dep_a::MsgSsrOrbitClockDepA; pub use msg_ssr_phase_biases::MsgSsrPhaseBiases; pub use msg_ssr_satellite_apc::MsgSsrSatelliteApc; pub use msg_ssr_stec_correction::MsgSsrStecCorrection; +pub use msg_ssr_stec_correction_dep::MsgSsrStecCorrectionDep; pub use msg_ssr_stec_correction_dep_a::MsgSsrStecCorrectionDepA; pub use msg_ssr_tile_definition::MsgSsrTileDefinition; +pub use msg_ssr_tile_definition_dep::MsgSsrTileDefinitionDep; pub use phase_biases_content::PhaseBiasesContent; pub use satellite_apc::SatelliteAPC; pub use stec_header::STECHeader; @@ -424,6 +430,73 @@ pub mod msg_ssr_code_biases { } } +pub mod msg_ssr_code_phase_biases_bounds { + #![allow(unused_imports)] + + use super::*; + use crate::messages::gnss::*; + use crate::messages::lib::*; + /// Stubbed version of Combined Code and Phase Biases Bounds + #[cfg_attr(feature = "serde", derive(serde::Serialize))] + #[derive(Debug, Clone)] + pub struct MsgSsrCodePhaseBiasesBounds { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing))] + pub sender_id: Option, + #[cfg_attr(feature = "serde", serde(rename(serialize = "stub")))] + pub stub: Vec, + } + + impl ConcreteMessage for MsgSsrCodePhaseBiasesBounds { + const MESSAGE_TYPE: u16 = 1516; + const MESSAGE_NAME: &'static str = "MSG_SSR_CODE_PHASE_BIASES_BOUNDS"; + } + + impl SbpMessage for MsgSsrCodePhaseBiasesBounds { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> u16 { + ::MESSAGE_TYPE + } + fn sender_id(&self) -> Option { + self.sender_id + } + fn set_sender_id(&mut self, new_id: u16) { + self.sender_id = Some(new_id); + } + fn encoded_len(&self) -> usize { + WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN + } + } + + impl TryFrom for MsgSsrCodePhaseBiasesBounds { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgSsrCodePhaseBiasesBounds(m) => Ok(m), + _ => Err(TryFromSbpError), + } + } + } + + impl WireFormat for MsgSsrCodePhaseBiasesBounds { + const MIN_LEN: usize = as WireFormat>::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.stub) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.stub, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgSsrCodePhaseBiasesBounds { + sender_id: None, + stub: WireFormat::parse_unchecked(buf), + } + } + } +} + pub mod msg_ssr_gridded_correction { #![allow(unused_imports)] @@ -519,6 +592,73 @@ pub mod msg_ssr_gridded_correction { } } +pub mod msg_ssr_gridded_correction_bounds { + #![allow(unused_imports)] + + use super::*; + use crate::messages::gnss::*; + use crate::messages::lib::*; + /// Gridded troposhere and STEC correction residuals bounds + #[cfg_attr(feature = "serde", derive(serde::Serialize))] + #[derive(Debug, Clone)] + pub struct MsgSsrGriddedCorrectionBounds { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing))] + pub sender_id: Option, + #[cfg_attr(feature = "serde", serde(rename(serialize = "stub")))] + pub stub: Vec, + } + + impl ConcreteMessage for MsgSsrGriddedCorrectionBounds { + const MESSAGE_TYPE: u16 = 1534; + const MESSAGE_NAME: &'static str = "MSG_SSR_GRIDDED_CORRECTION_BOUNDS"; + } + + impl SbpMessage for MsgSsrGriddedCorrectionBounds { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> u16 { + ::MESSAGE_TYPE + } + fn sender_id(&self) -> Option { + self.sender_id + } + fn set_sender_id(&mut self, new_id: u16) { + self.sender_id = Some(new_id); + } + fn encoded_len(&self) -> usize { + WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN + } + } + + impl TryFrom for MsgSsrGriddedCorrectionBounds { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgSsrGriddedCorrectionBounds(m) => Ok(m), + _ => Err(TryFromSbpError), + } + } + } + + impl WireFormat for MsgSsrGriddedCorrectionBounds { + const MIN_LEN: usize = as WireFormat>::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.stub) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.stub, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgSsrGriddedCorrectionBounds { + sender_id: None, + stub: WireFormat::parse_unchecked(buf), + } + } + } +} + pub mod msg_ssr_gridded_correction_dep_a { #![allow(unused_imports)] @@ -941,6 +1081,140 @@ pub mod msg_ssr_orbit_clock { } } +pub mod msg_ssr_orbit_clock_bounds { + #![allow(unused_imports)] + + use super::*; + use crate::messages::gnss::*; + use crate::messages::lib::*; + /// Stubbed version of Combined Orbit and Clock Bound + #[cfg_attr(feature = "serde", derive(serde::Serialize))] + #[derive(Debug, Clone)] + pub struct MsgSsrOrbitClockBounds { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing))] + pub sender_id: Option, + #[cfg_attr(feature = "serde", serde(rename(serialize = "stub")))] + pub stub: Vec, + } + + impl ConcreteMessage for MsgSsrOrbitClockBounds { + const MESSAGE_TYPE: u16 = 1502; + const MESSAGE_NAME: &'static str = "MSG_SSR_ORBIT_CLOCK_BOUNDS"; + } + + impl SbpMessage for MsgSsrOrbitClockBounds { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> u16 { + ::MESSAGE_TYPE + } + fn sender_id(&self) -> Option { + self.sender_id + } + fn set_sender_id(&mut self, new_id: u16) { + self.sender_id = Some(new_id); + } + fn encoded_len(&self) -> usize { + WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN + } + } + + impl TryFrom for MsgSsrOrbitClockBounds { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgSsrOrbitClockBounds(m) => Ok(m), + _ => Err(TryFromSbpError), + } + } + } + + impl WireFormat for MsgSsrOrbitClockBounds { + const MIN_LEN: usize = as WireFormat>::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.stub) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.stub, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgSsrOrbitClockBounds { + sender_id: None, + stub: WireFormat::parse_unchecked(buf), + } + } + } +} + +pub mod msg_ssr_orbit_clock_bounds_degradation { + #![allow(unused_imports)] + + use super::*; + use crate::messages::gnss::*; + use crate::messages::lib::*; + /// Combined Orbit and Clock Bound Degradation Parameter + #[cfg_attr(feature = "serde", derive(serde::Serialize))] + #[derive(Debug, Clone)] + pub struct MsgSsrOrbitClockBoundsDegradation { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing))] + pub sender_id: Option, + #[cfg_attr(feature = "serde", serde(rename(serialize = "stub")))] + pub stub: Vec, + } + + impl ConcreteMessage for MsgSsrOrbitClockBoundsDegradation { + const MESSAGE_TYPE: u16 = 1503; + const MESSAGE_NAME: &'static str = "MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION"; + } + + impl SbpMessage for MsgSsrOrbitClockBoundsDegradation { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> u16 { + ::MESSAGE_TYPE + } + fn sender_id(&self) -> Option { + self.sender_id + } + fn set_sender_id(&mut self, new_id: u16) { + self.sender_id = Some(new_id); + } + fn encoded_len(&self) -> usize { + WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN + } + } + + impl TryFrom for MsgSsrOrbitClockBoundsDegradation { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgSsrOrbitClockBoundsDegradation(m) => Ok(m), + _ => Err(TryFromSbpError), + } + } + } + + impl WireFormat for MsgSsrOrbitClockBoundsDegradation { + const MIN_LEN: usize = as WireFormat>::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.stub) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.stub, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgSsrOrbitClockBoundsDegradation { + sender_id: None, + stub: WireFormat::parse_unchecked(buf), + } + } + } +} + pub mod msg_ssr_orbit_clock_dep_a { #![allow(unused_imports)] @@ -1307,6 +1581,73 @@ pub mod msg_ssr_satellite_apc { pub mod msg_ssr_stec_correction { #![allow(unused_imports)] + use super::*; + use crate::messages::gnss::*; + use crate::messages::lib::*; + /// STEC correction polynomial coefficients + #[cfg_attr(feature = "serde", derive(serde::Serialize))] + #[derive(Debug, Clone)] + pub struct MsgSsrStecCorrection { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing))] + pub sender_id: Option, + #[cfg_attr(feature = "serde", serde(rename(serialize = "stub")))] + pub stub: Vec, + } + + impl ConcreteMessage for MsgSsrStecCorrection { + const MESSAGE_TYPE: u16 = 1533; + const MESSAGE_NAME: &'static str = "MSG_SSR_STEC_CORRECTION"; + } + + impl SbpMessage for MsgSsrStecCorrection { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> u16 { + ::MESSAGE_TYPE + } + fn sender_id(&self) -> Option { + self.sender_id + } + fn set_sender_id(&mut self, new_id: u16) { + self.sender_id = Some(new_id); + } + fn encoded_len(&self) -> usize { + WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN + } + } + + impl TryFrom for MsgSsrStecCorrection { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgSsrStecCorrection(m) => Ok(m), + _ => Err(TryFromSbpError), + } + } + } + + impl WireFormat for MsgSsrStecCorrection { + const MIN_LEN: usize = as WireFormat>::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.stub) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.stub, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgSsrStecCorrection { + sender_id: None, + stub: WireFormat::parse_unchecked(buf), + } + } + } +} + +pub mod msg_ssr_stec_correction_dep { + #![allow(unused_imports)] + use super::*; use crate::messages::gnss::*; use crate::messages::lib::*; @@ -1322,7 +1663,7 @@ pub mod msg_ssr_stec_correction { /// #[cfg_attr(feature = "serde", derive(serde::Serialize))] #[derive(Debug, Clone)] - pub struct MsgSsrStecCorrection { + pub struct MsgSsrStecCorrectionDep { /// The message sender_id #[cfg_attr(feature = "serde", serde(skip_serializing))] pub sender_id: Option, @@ -1334,12 +1675,12 @@ pub mod msg_ssr_stec_correction { pub stec_sat_list: Vec, } - impl ConcreteMessage for MsgSsrStecCorrection { + impl ConcreteMessage for MsgSsrStecCorrectionDep { const MESSAGE_TYPE: u16 = 1531; - const MESSAGE_NAME: &'static str = "MSG_SSR_STEC_CORRECTION"; + const MESSAGE_NAME: &'static str = "MSG_SSR_STEC_CORRECTION_DEP"; } - impl SbpMessage for MsgSsrStecCorrection { + impl SbpMessage for MsgSsrStecCorrectionDep { fn message_name(&self) -> &'static str { ::MESSAGE_NAME } @@ -1357,17 +1698,17 @@ pub mod msg_ssr_stec_correction { } } - impl TryFrom for MsgSsrStecCorrection { + impl TryFrom for MsgSsrStecCorrectionDep { type Error = TryFromSbpError; fn try_from(msg: Sbp) -> Result { match msg { - Sbp::MsgSsrStecCorrection(m) => Ok(m), + Sbp::MsgSsrStecCorrectionDep(m) => Ok(m), _ => Err(TryFromSbpError), } } } - impl WireFormat for MsgSsrStecCorrection { + impl WireFormat for MsgSsrStecCorrectionDep { const MIN_LEN: usize = ::MIN_LEN + as WireFormat>::MIN_LEN; fn len(&self) -> usize { @@ -1378,7 +1719,7 @@ pub mod msg_ssr_stec_correction { WireFormat::write(&self.stec_sat_list, buf); } fn parse_unchecked(buf: &mut B) -> Self { - MsgSsrStecCorrection { + MsgSsrStecCorrectionDep { sender_id: None, header: WireFormat::parse_unchecked(buf), stec_sat_list: WireFormat::parse_unchecked(buf), @@ -1482,6 +1823,84 @@ pub mod msg_ssr_tile_definition { #[cfg_attr(feature = "serde", derive(serde::Serialize))] #[derive(Debug, Clone)] pub struct MsgSsrTileDefinition { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing))] + pub sender_id: Option, + #[cfg_attr(feature = "serde", serde(rename(serialize = "stub")))] + pub stub: Vec, + } + + impl ConcreteMessage for MsgSsrTileDefinition { + const MESSAGE_TYPE: u16 = 1527; + const MESSAGE_NAME: &'static str = "MSG_SSR_TILE_DEFINITION"; + } + + impl SbpMessage for MsgSsrTileDefinition { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> u16 { + ::MESSAGE_TYPE + } + fn sender_id(&self) -> Option { + self.sender_id + } + fn set_sender_id(&mut self, new_id: u16) { + self.sender_id = Some(new_id); + } + fn encoded_len(&self) -> usize { + WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN + } + } + + impl TryFrom for MsgSsrTileDefinition { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgSsrTileDefinition(m) => Ok(m), + _ => Err(TryFromSbpError), + } + } + } + + impl WireFormat for MsgSsrTileDefinition { + const MIN_LEN: usize = as WireFormat>::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.stub) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.stub, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgSsrTileDefinition { + sender_id: None, + stub: WireFormat::parse_unchecked(buf), + } + } + } +} + +pub mod msg_ssr_tile_definition_dep { + #![allow(unused_imports)] + + use super::*; + use crate::messages::gnss::*; + use crate::messages::lib::*; + + /// Definition of a SSR atmospheric correction tile. + + /// + /// Provides the correction point coordinates for the atmospheric correction + /// values in the MSG_SSR_STEC_CORRECTION_DEP and MSG_SSR_GRIDDED_CORRECTION + /// messages. + /// + /// Based on ETSI TS 137 355 V16.1.0 (LTE Positioning Protocol) information + /// element GNSS-SSR-CorrectionPoints. SBP only supports gridded arrays of + /// correction points, not lists of points. + /// + #[cfg_attr(feature = "serde", derive(serde::Serialize))] + #[derive(Debug, Clone)] + pub struct MsgSsrTileDefinitionDep { /// The message sender_id #[cfg_attr(feature = "serde", serde(skip_serializing))] pub sender_id: Option, @@ -1551,12 +1970,12 @@ pub mod msg_ssr_tile_definition { pub bitmask: u64, } - impl ConcreteMessage for MsgSsrTileDefinition { + impl ConcreteMessage for MsgSsrTileDefinitionDep { const MESSAGE_TYPE: u16 = 1526; - const MESSAGE_NAME: &'static str = "MSG_SSR_TILE_DEFINITION"; + const MESSAGE_NAME: &'static str = "MSG_SSR_TILE_DEFINITION_DEP"; } - impl SbpMessage for MsgSsrTileDefinition { + impl SbpMessage for MsgSsrTileDefinitionDep { fn message_name(&self) -> &'static str { ::MESSAGE_NAME } @@ -1574,17 +1993,17 @@ pub mod msg_ssr_tile_definition { } } - impl TryFrom for MsgSsrTileDefinition { + impl TryFrom for MsgSsrTileDefinitionDep { type Error = TryFromSbpError; fn try_from(msg: Sbp) -> Result { match msg { - Sbp::MsgSsrTileDefinition(m) => Ok(m), + Sbp::MsgSsrTileDefinitionDep(m) => Ok(m), _ => Err(TryFromSbpError), } } } - impl WireFormat for MsgSsrTileDefinition { + impl WireFormat for MsgSsrTileDefinitionDep { const MIN_LEN: usize = ::MIN_LEN + ::MIN_LEN + ::MIN_LEN @@ -1617,7 +2036,7 @@ pub mod msg_ssr_tile_definition { WireFormat::write(&self.bitmask, buf); } fn parse_unchecked(buf: &mut B) -> Self { - MsgSsrTileDefinition { + MsgSsrTileDefinitionDep { sender_id: None, tile_set_id: WireFormat::parse_unchecked(buf), tile_id: WireFormat::parse_unchecked(buf), diff --git a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs new file mode 100644 index 0000000000..f9ecef3a25 --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs @@ -0,0 +1,206 @@ +// +// Copyright (C) 2019-2021 Swift Navigation Inc. +// Contact: https://support.swiftnav.com +// +// This source is subject to the license found in the file 'LICENSE' which must +// be be distributed together with this source. All other rights reserved. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml by generate.py. Do not modify by hand! + +use crate::*; + +#[test] +fn test_auto_check_sbp_integrity_msg_ssr_flag_high_level() { + { + let mut payload = Cursor::new(vec![ + 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, + 1, 2, 3, 0, 0, 0, 0, 0, 0, 4, 5, 6, 7, 102, 67, + ]); + + // Test the round trip payload parsing + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + match &sbp_msg { + sbp::messages::Sbp::MsgSsrFlagHighLevel(msg) => { + assert_eq!( + msg.message_type(), + 3001, + "Incorrect message type, expected 3001, is {}", + msg.message_type() + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {}", + sender_id + ); + assert_eq!( + msg.stub[0], 180, + "incorrect value for stub[0], expected 180, is {}", + msg.stub[0] + ); + assert_eq!( + msg.stub[1], 0, + "incorrect value for stub[1], expected 0, is {}", + msg.stub[1] + ); + assert_eq!( + msg.stub[2], 0, + "incorrect value for stub[2], expected 0, is {}", + msg.stub[2] + ); + assert_eq!( + msg.stub[3], 0, + "incorrect value for stub[3], expected 0, is {}", + msg.stub[3] + ); + assert_eq!( + msg.stub[4], 3, + "incorrect value for stub[4], expected 3, is {}", + msg.stub[4] + ); + assert_eq!( + msg.stub[5], 0, + "incorrect value for stub[5], expected 0, is {}", + msg.stub[5] + ); + assert_eq!( + msg.stub[6], 104, + "incorrect value for stub[6], expected 104, is {}", + msg.stub[6] + ); + assert_eq!( + msg.stub[7], 1, + "incorrect value for stub[7], expected 1, is {}", + msg.stub[7] + ); + assert_eq!( + msg.stub[8], 0, + "incorrect value for stub[8], expected 0, is {}", + msg.stub[8] + ); + assert_eq!( + msg.stub[9], 0, + "incorrect value for stub[9], expected 0, is {}", + msg.stub[9] + ); + assert_eq!( + msg.stub[10], 6, + "incorrect value for stub[10], expected 6, is {}", + msg.stub[10] + ); + assert_eq!( + msg.stub[11], 0, + "incorrect value for stub[11], expected 0, is {}", + msg.stub[11] + ); + assert_eq!( + msg.stub[12], 10, + "incorrect value for stub[12], expected 10, is {}", + msg.stub[12] + ); + assert_eq!( + msg.stub[13], 20, + "incorrect value for stub[13], expected 20, is {}", + msg.stub[13] + ); + assert_eq!( + msg.stub[14], 0, + "incorrect value for stub[14], expected 0, is {}", + msg.stub[14] + ); + assert_eq!( + msg.stub[15], 30, + "incorrect value for stub[15], expected 30, is {}", + msg.stub[15] + ); + assert_eq!( + msg.stub[16], 0, + "incorrect value for stub[16], expected 0, is {}", + msg.stub[16] + ); + assert_eq!( + msg.stub[17], 40, + "incorrect value for stub[17], expected 40, is {}", + msg.stub[17] + ); + assert_eq!( + msg.stub[18], 1, + "incorrect value for stub[18], expected 1, is {}", + msg.stub[18] + ); + assert_eq!( + msg.stub[19], 2, + "incorrect value for stub[19], expected 2, is {}", + msg.stub[19] + ); + assert_eq!( + msg.stub[20], 3, + "incorrect value for stub[20], expected 3, is {}", + msg.stub[20] + ); + assert_eq!( + msg.stub[21], 0, + "incorrect value for stub[21], expected 0, is {}", + msg.stub[21] + ); + assert_eq!( + msg.stub[22], 0, + "incorrect value for stub[22], expected 0, is {}", + msg.stub[22] + ); + assert_eq!( + msg.stub[23], 0, + "incorrect value for stub[23], expected 0, is {}", + msg.stub[23] + ); + assert_eq!( + msg.stub[24], 0, + "incorrect value for stub[24], expected 0, is {}", + msg.stub[24] + ); + assert_eq!( + msg.stub[25], 0, + "incorrect value for stub[25], expected 0, is {}", + msg.stub[25] + ); + assert_eq!( + msg.stub[26], 0, + "incorrect value for stub[26], expected 0, is {}", + msg.stub[26] + ); + assert_eq!( + msg.stub[27], 4, + "incorrect value for stub[27], expected 4, is {}", + msg.stub[27] + ); + assert_eq!( + msg.stub[28], 5, + "incorrect value for stub[28], expected 5, is {}", + msg.stub[28] + ); + assert_eq!( + msg.stub[29], 6, + "incorrect value for stub[29], expected 6, is {}", + msg.stub[29] + ); + assert_eq!( + msg.stub[30], 7, + "incorrect value for stub[30], expected 7, is {}", + msg.stub[30] + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrFlagHighLevel"), + }; + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} diff --git a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_iono_grid_point_sat_los.rs b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_iono_grid_point_sat_los.rs new file mode 100644 index 0000000000..f26bb9f3cc --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_iono_grid_point_sat_los.rs @@ -0,0 +1,156 @@ +// +// Copyright (C) 2019-2021 Swift Navigation Inc. +// Contact: https://support.swiftnav.com +// +// This source is subject to the license found in the file 'LICENSE' which must +// be be distributed together with this source. All other rights reserved. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPointSatLos.yaml by generate.py. Do not modify by hand! + +use crate::*; + +#[test] +fn test_auto_check_sbp_integrity_msg_ssr_flag_iono_grid_point_sat_los() { + { + let mut payload = Cursor::new(vec![ + 85, 209, 11, 66, 0, 21, 180, 0, 0, 0, 3, 0, 1, 2, 3, 4, 0, 5, 0, 6, 30, 0, 2, 10, 11, + 15, 14, 98, 148, + ]); + + // Test the round trip payload parsing + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + match &sbp_msg { + sbp::messages::Sbp::MsgSsrFlagIonoGridPointSatLos(msg) => { + assert_eq!( + msg.message_type(), + 3025, + "Incorrect message type, expected 3025, is {}", + msg.message_type() + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {}", + sender_id + ); + assert_eq!( + msg.stub[0], 180, + "incorrect value for stub[0], expected 180, is {}", + msg.stub[0] + ); + assert_eq!( + msg.stub[1], 0, + "incorrect value for stub[1], expected 0, is {}", + msg.stub[1] + ); + assert_eq!( + msg.stub[2], 0, + "incorrect value for stub[2], expected 0, is {}", + msg.stub[2] + ); + assert_eq!( + msg.stub[3], 0, + "incorrect value for stub[3], expected 0, is {}", + msg.stub[3] + ); + assert_eq!( + msg.stub[4], 3, + "incorrect value for stub[4], expected 3, is {}", + msg.stub[4] + ); + assert_eq!( + msg.stub[5], 0, + "incorrect value for stub[5], expected 0, is {}", + msg.stub[5] + ); + assert_eq!( + msg.stub[6], 1, + "incorrect value for stub[6], expected 1, is {}", + msg.stub[6] + ); + assert_eq!( + msg.stub[7], 2, + "incorrect value for stub[7], expected 2, is {}", + msg.stub[7] + ); + assert_eq!( + msg.stub[8], 3, + "incorrect value for stub[8], expected 3, is {}", + msg.stub[8] + ); + assert_eq!( + msg.stub[9], 4, + "incorrect value for stub[9], expected 4, is {}", + msg.stub[9] + ); + assert_eq!( + msg.stub[10], 0, + "incorrect value for stub[10], expected 0, is {}", + msg.stub[10] + ); + assert_eq!( + msg.stub[11], 5, + "incorrect value for stub[11], expected 5, is {}", + msg.stub[11] + ); + assert_eq!( + msg.stub[12], 0, + "incorrect value for stub[12], expected 0, is {}", + msg.stub[12] + ); + assert_eq!( + msg.stub[13], 6, + "incorrect value for stub[13], expected 6, is {}", + msg.stub[13] + ); + assert_eq!( + msg.stub[14], 30, + "incorrect value for stub[14], expected 30, is {}", + msg.stub[14] + ); + assert_eq!( + msg.stub[15], 0, + "incorrect value for stub[15], expected 0, is {}", + msg.stub[15] + ); + assert_eq!( + msg.stub[16], 2, + "incorrect value for stub[16], expected 2, is {}", + msg.stub[16] + ); + assert_eq!( + msg.stub[17], 10, + "incorrect value for stub[17], expected 10, is {}", + msg.stub[17] + ); + assert_eq!( + msg.stub[18], 11, + "incorrect value for stub[18], expected 11, is {}", + msg.stub[18] + ); + assert_eq!( + msg.stub[19], 15, + "incorrect value for stub[19], expected 15, is {}", + msg.stub[19] + ); + assert_eq!( + msg.stub[20], 14, + "incorrect value for stub[20], expected 14, is {}", + msg.stub[20] + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrFlagIonoGridPointSatLos"), + }; + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} diff --git a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_iono_grid_points.rs b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_iono_grid_points.rs new file mode 100644 index 0000000000..88e2628d9b --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_iono_grid_points.rs @@ -0,0 +1,156 @@ +// +// Copyright (C) 2019-2021 Swift Navigation Inc. +// Contact: https://support.swiftnav.com +// +// This source is subject to the license found in the file 'LICENSE' which must +// be be distributed together with this source. All other rights reserved. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPoints.yaml by generate.py. Do not modify by hand! + +use crate::*; + +#[test] +fn test_auto_check_sbp_integrity_msg_ssr_flag_iono_grid_points() { + { + let mut payload = Cursor::new(vec![ + 85, 199, 11, 66, 0, 21, 180, 0, 0, 0, 3, 0, 1, 2, 3, 4, 0, 5, 0, 6, 3, 10, 0, 11, 0, + 12, 0, 53, 7, + ]); + + // Test the round trip payload parsing + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + match &sbp_msg { + sbp::messages::Sbp::MsgSsrFlagIonoGridPoints(msg) => { + assert_eq!( + msg.message_type(), + 3015, + "Incorrect message type, expected 3015, is {}", + msg.message_type() + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {}", + sender_id + ); + assert_eq!( + msg.stub[0], 180, + "incorrect value for stub[0], expected 180, is {}", + msg.stub[0] + ); + assert_eq!( + msg.stub[1], 0, + "incorrect value for stub[1], expected 0, is {}", + msg.stub[1] + ); + assert_eq!( + msg.stub[2], 0, + "incorrect value for stub[2], expected 0, is {}", + msg.stub[2] + ); + assert_eq!( + msg.stub[3], 0, + "incorrect value for stub[3], expected 0, is {}", + msg.stub[3] + ); + assert_eq!( + msg.stub[4], 3, + "incorrect value for stub[4], expected 3, is {}", + msg.stub[4] + ); + assert_eq!( + msg.stub[5], 0, + "incorrect value for stub[5], expected 0, is {}", + msg.stub[5] + ); + assert_eq!( + msg.stub[6], 1, + "incorrect value for stub[6], expected 1, is {}", + msg.stub[6] + ); + assert_eq!( + msg.stub[7], 2, + "incorrect value for stub[7], expected 2, is {}", + msg.stub[7] + ); + assert_eq!( + msg.stub[8], 3, + "incorrect value for stub[8], expected 3, is {}", + msg.stub[8] + ); + assert_eq!( + msg.stub[9], 4, + "incorrect value for stub[9], expected 4, is {}", + msg.stub[9] + ); + assert_eq!( + msg.stub[10], 0, + "incorrect value for stub[10], expected 0, is {}", + msg.stub[10] + ); + assert_eq!( + msg.stub[11], 5, + "incorrect value for stub[11], expected 5, is {}", + msg.stub[11] + ); + assert_eq!( + msg.stub[12], 0, + "incorrect value for stub[12], expected 0, is {}", + msg.stub[12] + ); + assert_eq!( + msg.stub[13], 6, + "incorrect value for stub[13], expected 6, is {}", + msg.stub[13] + ); + assert_eq!( + msg.stub[14], 3, + "incorrect value for stub[14], expected 3, is {}", + msg.stub[14] + ); + assert_eq!( + msg.stub[15], 10, + "incorrect value for stub[15], expected 10, is {}", + msg.stub[15] + ); + assert_eq!( + msg.stub[16], 0, + "incorrect value for stub[16], expected 0, is {}", + msg.stub[16] + ); + assert_eq!( + msg.stub[17], 11, + "incorrect value for stub[17], expected 11, is {}", + msg.stub[17] + ); + assert_eq!( + msg.stub[18], 0, + "incorrect value for stub[18], expected 0, is {}", + msg.stub[18] + ); + assert_eq!( + msg.stub[19], 12, + "incorrect value for stub[19], expected 12, is {}", + msg.stub[19] + ); + assert_eq!( + msg.stub[20], 0, + "incorrect value for stub[20], expected 0, is {}", + msg.stub[20] + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrFlagIonoGridPoints"), + }; + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} diff --git a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_iono_tile_sat_los.rs b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_iono_tile_sat_los.rs new file mode 100644 index 0000000000..1b0e7020cb --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_iono_tile_sat_los.rs @@ -0,0 +1,146 @@ +// +// Copyright (C) 2019-2021 Swift Navigation Inc. +// Contact: https://support.swiftnav.com +// +// This source is subject to the license found in the file 'LICENSE' which must +// be be distributed together with this source. All other rights reserved. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoTileSatLos.yaml by generate.py. Do not modify by hand! + +use crate::*; + +#[test] +fn test_auto_check_sbp_integrity_msg_ssr_flag_iono_tile_sat_los() { + { + let mut payload = Cursor::new(vec![ + 85, 205, 11, 66, 0, 19, 180, 0, 0, 0, 3, 0, 1, 2, 3, 4, 0, 5, 0, 6, 2, 10, 11, 15, 14, + 239, 235, + ]); + + // Test the round trip payload parsing + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + match &sbp_msg { + sbp::messages::Sbp::MsgSsrFlagIonoTileSatLos(msg) => { + assert_eq!( + msg.message_type(), + 3021, + "Incorrect message type, expected 3021, is {}", + msg.message_type() + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {}", + sender_id + ); + assert_eq!( + msg.stub[0], 180, + "incorrect value for stub[0], expected 180, is {}", + msg.stub[0] + ); + assert_eq!( + msg.stub[1], 0, + "incorrect value for stub[1], expected 0, is {}", + msg.stub[1] + ); + assert_eq!( + msg.stub[2], 0, + "incorrect value for stub[2], expected 0, is {}", + msg.stub[2] + ); + assert_eq!( + msg.stub[3], 0, + "incorrect value for stub[3], expected 0, is {}", + msg.stub[3] + ); + assert_eq!( + msg.stub[4], 3, + "incorrect value for stub[4], expected 3, is {}", + msg.stub[4] + ); + assert_eq!( + msg.stub[5], 0, + "incorrect value for stub[5], expected 0, is {}", + msg.stub[5] + ); + assert_eq!( + msg.stub[6], 1, + "incorrect value for stub[6], expected 1, is {}", + msg.stub[6] + ); + assert_eq!( + msg.stub[7], 2, + "incorrect value for stub[7], expected 2, is {}", + msg.stub[7] + ); + assert_eq!( + msg.stub[8], 3, + "incorrect value for stub[8], expected 3, is {}", + msg.stub[8] + ); + assert_eq!( + msg.stub[9], 4, + "incorrect value for stub[9], expected 4, is {}", + msg.stub[9] + ); + assert_eq!( + msg.stub[10], 0, + "incorrect value for stub[10], expected 0, is {}", + msg.stub[10] + ); + assert_eq!( + msg.stub[11], 5, + "incorrect value for stub[11], expected 5, is {}", + msg.stub[11] + ); + assert_eq!( + msg.stub[12], 0, + "incorrect value for stub[12], expected 0, is {}", + msg.stub[12] + ); + assert_eq!( + msg.stub[13], 6, + "incorrect value for stub[13], expected 6, is {}", + msg.stub[13] + ); + assert_eq!( + msg.stub[14], 2, + "incorrect value for stub[14], expected 2, is {}", + msg.stub[14] + ); + assert_eq!( + msg.stub[15], 10, + "incorrect value for stub[15], expected 10, is {}", + msg.stub[15] + ); + assert_eq!( + msg.stub[16], 11, + "incorrect value for stub[16], expected 11, is {}", + msg.stub[16] + ); + assert_eq!( + msg.stub[17], 15, + "incorrect value for stub[17], expected 15, is {}", + msg.stub[17] + ); + assert_eq!( + msg.stub[18], 14, + "incorrect value for stub[18], expected 14, is {}", + msg.stub[18] + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrFlagIonoTileSatLos"), + }; + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} diff --git a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_satellites.rs b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_satellites.rs new file mode 100644 index 0000000000..268646855d --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_satellites.rs @@ -0,0 +1,125 @@ +// +// Copyright (C) 2019-2021 Swift Navigation Inc. +// Contact: https://support.swiftnav.com +// +// This source is subject to the license found in the file 'LICENSE' which must +// be be distributed together with this source. All other rights reserved. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagSatellites.yaml by generate.py. Do not modify by hand! + +use crate::*; + +#[test] +fn test_auto_check_sbp_integrity_msg_ssr_flag_satellites() { + { + let mut payload = Cursor::new(vec![ + 85, 189, 11, 66, 0, 15, 180, 0, 0, 0, 3, 0, 1, 2, 3, 4, 5, 3, 10, 11, 12, 110, 165, + ]); + + // Test the round trip payload parsing + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + match &sbp_msg { + sbp::messages::Sbp::MsgSsrFlagSatellites(msg) => { + assert_eq!( + msg.message_type(), + 3005, + "Incorrect message type, expected 3005, is {}", + msg.message_type() + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {}", + sender_id + ); + assert_eq!( + msg.stub[0], 180, + "incorrect value for stub[0], expected 180, is {}", + msg.stub[0] + ); + assert_eq!( + msg.stub[1], 0, + "incorrect value for stub[1], expected 0, is {}", + msg.stub[1] + ); + assert_eq!( + msg.stub[2], 0, + "incorrect value for stub[2], expected 0, is {}", + msg.stub[2] + ); + assert_eq!( + msg.stub[3], 0, + "incorrect value for stub[3], expected 0, is {}", + msg.stub[3] + ); + assert_eq!( + msg.stub[4], 3, + "incorrect value for stub[4], expected 3, is {}", + msg.stub[4] + ); + assert_eq!( + msg.stub[5], 0, + "incorrect value for stub[5], expected 0, is {}", + msg.stub[5] + ); + assert_eq!( + msg.stub[6], 1, + "incorrect value for stub[6], expected 1, is {}", + msg.stub[6] + ); + assert_eq!( + msg.stub[7], 2, + "incorrect value for stub[7], expected 2, is {}", + msg.stub[7] + ); + assert_eq!( + msg.stub[8], 3, + "incorrect value for stub[8], expected 3, is {}", + msg.stub[8] + ); + assert_eq!( + msg.stub[9], 4, + "incorrect value for stub[9], expected 4, is {}", + msg.stub[9] + ); + assert_eq!( + msg.stub[10], 5, + "incorrect value for stub[10], expected 5, is {}", + msg.stub[10] + ); + assert_eq!( + msg.stub[11], 3, + "incorrect value for stub[11], expected 3, is {}", + msg.stub[11] + ); + assert_eq!( + msg.stub[12], 10, + "incorrect value for stub[12], expected 10, is {}", + msg.stub[12] + ); + assert_eq!( + msg.stub[13], 11, + "incorrect value for stub[13], expected 11, is {}", + msg.stub[13] + ); + assert_eq!( + msg.stub[14], 12, + "incorrect value for stub[14], expected 12, is {}", + msg.stub[14] + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrFlagSatellites"), + }; + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} diff --git a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_tropo_grid_points.rs b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_tropo_grid_points.rs new file mode 100644 index 0000000000..a43ddbc987 --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_tropo_grid_points.rs @@ -0,0 +1,156 @@ +// +// Copyright (C) 2019-2021 Swift Navigation Inc. +// Contact: https://support.swiftnav.com +// +// This source is subject to the license found in the file 'LICENSE' which must +// be be distributed together with this source. All other rights reserved. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagTropoGridPoints.yaml by generate.py. Do not modify by hand! + +use crate::*; + +#[test] +fn test_auto_check_sbp_integrity_msg_ssr_flag_tropo_grid_points() { + { + let mut payload = Cursor::new(vec![ + 85, 195, 11, 66, 0, 21, 180, 0, 0, 0, 3, 0, 1, 2, 3, 4, 0, 5, 0, 6, 3, 10, 0, 11, 0, + 12, 0, 243, 150, + ]); + + // Test the round trip payload parsing + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + match &sbp_msg { + sbp::messages::Sbp::MsgSsrFlagTropoGridPoints(msg) => { + assert_eq!( + msg.message_type(), + 3011, + "Incorrect message type, expected 3011, is {}", + msg.message_type() + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {}", + sender_id + ); + assert_eq!( + msg.stub[0], 180, + "incorrect value for stub[0], expected 180, is {}", + msg.stub[0] + ); + assert_eq!( + msg.stub[1], 0, + "incorrect value for stub[1], expected 0, is {}", + msg.stub[1] + ); + assert_eq!( + msg.stub[2], 0, + "incorrect value for stub[2], expected 0, is {}", + msg.stub[2] + ); + assert_eq!( + msg.stub[3], 0, + "incorrect value for stub[3], expected 0, is {}", + msg.stub[3] + ); + assert_eq!( + msg.stub[4], 3, + "incorrect value for stub[4], expected 3, is {}", + msg.stub[4] + ); + assert_eq!( + msg.stub[5], 0, + "incorrect value for stub[5], expected 0, is {}", + msg.stub[5] + ); + assert_eq!( + msg.stub[6], 1, + "incorrect value for stub[6], expected 1, is {}", + msg.stub[6] + ); + assert_eq!( + msg.stub[7], 2, + "incorrect value for stub[7], expected 2, is {}", + msg.stub[7] + ); + assert_eq!( + msg.stub[8], 3, + "incorrect value for stub[8], expected 3, is {}", + msg.stub[8] + ); + assert_eq!( + msg.stub[9], 4, + "incorrect value for stub[9], expected 4, is {}", + msg.stub[9] + ); + assert_eq!( + msg.stub[10], 0, + "incorrect value for stub[10], expected 0, is {}", + msg.stub[10] + ); + assert_eq!( + msg.stub[11], 5, + "incorrect value for stub[11], expected 5, is {}", + msg.stub[11] + ); + assert_eq!( + msg.stub[12], 0, + "incorrect value for stub[12], expected 0, is {}", + msg.stub[12] + ); + assert_eq!( + msg.stub[13], 6, + "incorrect value for stub[13], expected 6, is {}", + msg.stub[13] + ); + assert_eq!( + msg.stub[14], 3, + "incorrect value for stub[14], expected 3, is {}", + msg.stub[14] + ); + assert_eq!( + msg.stub[15], 10, + "incorrect value for stub[15], expected 10, is {}", + msg.stub[15] + ); + assert_eq!( + msg.stub[16], 0, + "incorrect value for stub[16], expected 0, is {}", + msg.stub[16] + ); + assert_eq!( + msg.stub[17], 11, + "incorrect value for stub[17], expected 11, is {}", + msg.stub[17] + ); + assert_eq!( + msg.stub[18], 0, + "incorrect value for stub[18], expected 0, is {}", + msg.stub[18] + ); + assert_eq!( + msg.stub[19], 12, + "incorrect value for stub[19], expected 12, is {}", + msg.stub[19] + ); + assert_eq!( + msg.stub[20], 0, + "incorrect value for stub[20], expected 0, is {}", + msg.stub[20] + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrFlagTropoGridPoints"), + }; + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} diff --git a/rust/sbp/tests/integration/auto_check_sbp_navigation_msg_gps_leap_second.rs b/rust/sbp/tests/integration/auto_check_sbp_navigation_msg_gps_leap_second.rs new file mode 100644 index 0000000000..08e52c9378 --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_navigation_msg_gps_leap_second.rs @@ -0,0 +1,120 @@ +// +// Copyright (C) 2019-2021 Swift Navigation Inc. +// Contact: https://support.swiftnav.com +// +// This source is subject to the license found in the file 'LICENSE' which must +// be be distributed together with this source. All other rights reserved. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSLeapSecond.yaml by generate.py. Do not modify by hand! + +use crate::*; + +#[test] +fn test_auto_check_sbp_navigation_msg_gps_leap_second() { + { + let mut payload = Cursor::new(vec![ + 85, 58, 2, 66, 0, 14, 1, 0, 2, 0, 3, 4, 5, 0, 6, 0, 7, 0, 8, 9, 50, 232, + ]); + + // Test the round trip payload parsing + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + match &sbp_msg { + sbp::messages::Sbp::MsgGpsLeapSecond(msg) => { + assert_eq!( + msg.message_type(), + 570, + "Incorrect message type, expected 570, is {}", + msg.message_type() + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {}", + sender_id + ); + assert_eq!( + msg.stub[0], 1, + "incorrect value for stub[0], expected 1, is {}", + msg.stub[0] + ); + assert_eq!( + msg.stub[1], 0, + "incorrect value for stub[1], expected 0, is {}", + msg.stub[1] + ); + assert_eq!( + msg.stub[2], 2, + "incorrect value for stub[2], expected 2, is {}", + msg.stub[2] + ); + assert_eq!( + msg.stub[3], 0, + "incorrect value for stub[3], expected 0, is {}", + msg.stub[3] + ); + assert_eq!( + msg.stub[4], 3, + "incorrect value for stub[4], expected 3, is {}", + msg.stub[4] + ); + assert_eq!( + msg.stub[5], 4, + "incorrect value for stub[5], expected 4, is {}", + msg.stub[5] + ); + assert_eq!( + msg.stub[6], 5, + "incorrect value for stub[6], expected 5, is {}", + msg.stub[6] + ); + assert_eq!( + msg.stub[7], 0, + "incorrect value for stub[7], expected 0, is {}", + msg.stub[7] + ); + assert_eq!( + msg.stub[8], 6, + "incorrect value for stub[8], expected 6, is {}", + msg.stub[8] + ); + assert_eq!( + msg.stub[9], 0, + "incorrect value for stub[9], expected 0, is {}", + msg.stub[9] + ); + assert_eq!( + msg.stub[10], 7, + "incorrect value for stub[10], expected 7, is {}", + msg.stub[10] + ); + assert_eq!( + msg.stub[11], 0, + "incorrect value for stub[11], expected 0, is {}", + msg.stub[11] + ); + assert_eq!( + msg.stub[12], 8, + "incorrect value for stub[12], expected 8, is {}", + msg.stub[12] + ); + assert_eq!( + msg.stub[13], 9, + "incorrect value for stub[13], expected 9, is {}", + msg.stub[13] + ); + } + _ => panic!("Invalid message type! Expected a MsgGPSLeapSecond"), + }; + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} diff --git a/rust/sbp/tests/integration/auto_check_sbp_navigation_msg_itrf.rs b/rust/sbp/tests/integration/auto_check_sbp_navigation_msg_itrf.rs new file mode 100644 index 0000000000..ee9e9ed36b --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_navigation_msg_itrf.rs @@ -0,0 +1,674 @@ +// +// Copyright (C) 2019-2021 Swift Navigation Inc. +// Contact: https://support.swiftnav.com +// +// This source is subject to the license found in the file 'LICENSE' which must +// be be distributed together with this source. All other rights reserved. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml by generate.py. Do not modify by hand! + +use crate::*; + +#[test] +fn test_auto_check_sbp_navigation_msg_itrf() { + { + let mut payload = Cursor::new(vec![ + 85, 68, 2, 66, 0, 124, 1, 2, 102, 111, 111, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 98, 97, 114, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 0, 6, 0, 7, 0, 0, 0, 8, 0, + 0, 0, 9, 0, 0, 0, 10, 0, 0, 0, 11, 0, 0, 0, 12, 0, 0, 0, 13, 0, 0, 0, 14, 0, 0, 0, 15, + 0, 0, 0, 16, 0, 0, 0, 17, 0, 0, 0, 18, 0, 0, 0, 19, 0, 0, 0, 20, 0, 66, 126, + ]); + + // Test the round trip payload parsing + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + match &sbp_msg { + sbp::messages::Sbp::MsgItrf(msg) => { + assert_eq!( + msg.message_type(), + 580, + "Incorrect message type, expected 580, is {}", + msg.message_type() + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {}", + sender_id + ); + assert_eq!( + msg.stub[0], 1, + "incorrect value for stub[0], expected 1, is {}", + msg.stub[0] + ); + assert_eq!( + msg.stub[1], 2, + "incorrect value for stub[1], expected 2, is {}", + msg.stub[1] + ); + assert_eq!( + msg.stub[2], 102, + "incorrect value for stub[2], expected 102, is {}", + msg.stub[2] + ); + assert_eq!( + msg.stub[3], 111, + "incorrect value for stub[3], expected 111, is {}", + msg.stub[3] + ); + assert_eq!( + msg.stub[4], 111, + "incorrect value for stub[4], expected 111, is {}", + msg.stub[4] + ); + assert_eq!( + msg.stub[5], 0, + "incorrect value for stub[5], expected 0, is {}", + msg.stub[5] + ); + assert_eq!( + msg.stub[6], 0, + "incorrect value for stub[6], expected 0, is {}", + msg.stub[6] + ); + assert_eq!( + msg.stub[7], 0, + "incorrect value for stub[7], expected 0, is {}", + msg.stub[7] + ); + assert_eq!( + msg.stub[8], 0, + "incorrect value for stub[8], expected 0, is {}", + msg.stub[8] + ); + assert_eq!( + msg.stub[9], 0, + "incorrect value for stub[9], expected 0, is {}", + msg.stub[9] + ); + assert_eq!( + msg.stub[10], 0, + "incorrect value for stub[10], expected 0, is {}", + msg.stub[10] + ); + assert_eq!( + msg.stub[11], 0, + "incorrect value for stub[11], expected 0, is {}", + msg.stub[11] + ); + assert_eq!( + msg.stub[12], 0, + "incorrect value for stub[12], expected 0, is {}", + msg.stub[12] + ); + assert_eq!( + msg.stub[13], 0, + "incorrect value for stub[13], expected 0, is {}", + msg.stub[13] + ); + assert_eq!( + msg.stub[14], 0, + "incorrect value for stub[14], expected 0, is {}", + msg.stub[14] + ); + assert_eq!( + msg.stub[15], 0, + "incorrect value for stub[15], expected 0, is {}", + msg.stub[15] + ); + assert_eq!( + msg.stub[16], 0, + "incorrect value for stub[16], expected 0, is {}", + msg.stub[16] + ); + assert_eq!( + msg.stub[17], 0, + "incorrect value for stub[17], expected 0, is {}", + msg.stub[17] + ); + assert_eq!( + msg.stub[18], 0, + "incorrect value for stub[18], expected 0, is {}", + msg.stub[18] + ); + assert_eq!( + msg.stub[19], 0, + "incorrect value for stub[19], expected 0, is {}", + msg.stub[19] + ); + assert_eq!( + msg.stub[20], 0, + "incorrect value for stub[20], expected 0, is {}", + msg.stub[20] + ); + assert_eq!( + msg.stub[21], 0, + "incorrect value for stub[21], expected 0, is {}", + msg.stub[21] + ); + assert_eq!( + msg.stub[22], 0, + "incorrect value for stub[22], expected 0, is {}", + msg.stub[22] + ); + assert_eq!( + msg.stub[23], 0, + "incorrect value for stub[23], expected 0, is {}", + msg.stub[23] + ); + assert_eq!( + msg.stub[24], 0, + "incorrect value for stub[24], expected 0, is {}", + msg.stub[24] + ); + assert_eq!( + msg.stub[25], 0, + "incorrect value for stub[25], expected 0, is {}", + msg.stub[25] + ); + assert_eq!( + msg.stub[26], 0, + "incorrect value for stub[26], expected 0, is {}", + msg.stub[26] + ); + assert_eq!( + msg.stub[27], 0, + "incorrect value for stub[27], expected 0, is {}", + msg.stub[27] + ); + assert_eq!( + msg.stub[28], 0, + "incorrect value for stub[28], expected 0, is {}", + msg.stub[28] + ); + assert_eq!( + msg.stub[29], 0, + "incorrect value for stub[29], expected 0, is {}", + msg.stub[29] + ); + assert_eq!( + msg.stub[30], 0, + "incorrect value for stub[30], expected 0, is {}", + msg.stub[30] + ); + assert_eq!( + msg.stub[31], 0, + "incorrect value for stub[31], expected 0, is {}", + msg.stub[31] + ); + assert_eq!( + msg.stub[32], 0, + "incorrect value for stub[32], expected 0, is {}", + msg.stub[32] + ); + assert_eq!( + msg.stub[33], 3, + "incorrect value for stub[33], expected 3, is {}", + msg.stub[33] + ); + assert_eq!( + msg.stub[34], 98, + "incorrect value for stub[34], expected 98, is {}", + msg.stub[34] + ); + assert_eq!( + msg.stub[35], 97, + "incorrect value for stub[35], expected 97, is {}", + msg.stub[35] + ); + assert_eq!( + msg.stub[36], 114, + "incorrect value for stub[36], expected 114, is {}", + msg.stub[36] + ); + assert_eq!( + msg.stub[37], 0, + "incorrect value for stub[37], expected 0, is {}", + msg.stub[37] + ); + assert_eq!( + msg.stub[38], 0, + "incorrect value for stub[38], expected 0, is {}", + msg.stub[38] + ); + assert_eq!( + msg.stub[39], 0, + "incorrect value for stub[39], expected 0, is {}", + msg.stub[39] + ); + assert_eq!( + msg.stub[40], 0, + "incorrect value for stub[40], expected 0, is {}", + msg.stub[40] + ); + assert_eq!( + msg.stub[41], 0, + "incorrect value for stub[41], expected 0, is {}", + msg.stub[41] + ); + assert_eq!( + msg.stub[42], 0, + "incorrect value for stub[42], expected 0, is {}", + msg.stub[42] + ); + assert_eq!( + msg.stub[43], 0, + "incorrect value for stub[43], expected 0, is {}", + msg.stub[43] + ); + assert_eq!( + msg.stub[44], 0, + "incorrect value for stub[44], expected 0, is {}", + msg.stub[44] + ); + assert_eq!( + msg.stub[45], 0, + "incorrect value for stub[45], expected 0, is {}", + msg.stub[45] + ); + assert_eq!( + msg.stub[46], 0, + "incorrect value for stub[46], expected 0, is {}", + msg.stub[46] + ); + assert_eq!( + msg.stub[47], 0, + "incorrect value for stub[47], expected 0, is {}", + msg.stub[47] + ); + assert_eq!( + msg.stub[48], 0, + "incorrect value for stub[48], expected 0, is {}", + msg.stub[48] + ); + assert_eq!( + msg.stub[49], 0, + "incorrect value for stub[49], expected 0, is {}", + msg.stub[49] + ); + assert_eq!( + msg.stub[50], 0, + "incorrect value for stub[50], expected 0, is {}", + msg.stub[50] + ); + assert_eq!( + msg.stub[51], 0, + "incorrect value for stub[51], expected 0, is {}", + msg.stub[51] + ); + assert_eq!( + msg.stub[52], 0, + "incorrect value for stub[52], expected 0, is {}", + msg.stub[52] + ); + assert_eq!( + msg.stub[53], 0, + "incorrect value for stub[53], expected 0, is {}", + msg.stub[53] + ); + assert_eq!( + msg.stub[54], 0, + "incorrect value for stub[54], expected 0, is {}", + msg.stub[54] + ); + assert_eq!( + msg.stub[55], 0, + "incorrect value for stub[55], expected 0, is {}", + msg.stub[55] + ); + assert_eq!( + msg.stub[56], 0, + "incorrect value for stub[56], expected 0, is {}", + msg.stub[56] + ); + assert_eq!( + msg.stub[57], 0, + "incorrect value for stub[57], expected 0, is {}", + msg.stub[57] + ); + assert_eq!( + msg.stub[58], 0, + "incorrect value for stub[58], expected 0, is {}", + msg.stub[58] + ); + assert_eq!( + msg.stub[59], 0, + "incorrect value for stub[59], expected 0, is {}", + msg.stub[59] + ); + assert_eq!( + msg.stub[60], 0, + "incorrect value for stub[60], expected 0, is {}", + msg.stub[60] + ); + assert_eq!( + msg.stub[61], 0, + "incorrect value for stub[61], expected 0, is {}", + msg.stub[61] + ); + assert_eq!( + msg.stub[62], 0, + "incorrect value for stub[62], expected 0, is {}", + msg.stub[62] + ); + assert_eq!( + msg.stub[63], 0, + "incorrect value for stub[63], expected 0, is {}", + msg.stub[63] + ); + assert_eq!( + msg.stub[64], 0, + "incorrect value for stub[64], expected 0, is {}", + msg.stub[64] + ); + assert_eq!( + msg.stub[65], 4, + "incorrect value for stub[65], expected 4, is {}", + msg.stub[65] + ); + assert_eq!( + msg.stub[66], 5, + "incorrect value for stub[66], expected 5, is {}", + msg.stub[66] + ); + assert_eq!( + msg.stub[67], 0, + "incorrect value for stub[67], expected 0, is {}", + msg.stub[67] + ); + assert_eq!( + msg.stub[68], 6, + "incorrect value for stub[68], expected 6, is {}", + msg.stub[68] + ); + assert_eq!( + msg.stub[69], 0, + "incorrect value for stub[69], expected 0, is {}", + msg.stub[69] + ); + assert_eq!( + msg.stub[70], 7, + "incorrect value for stub[70], expected 7, is {}", + msg.stub[70] + ); + assert_eq!( + msg.stub[71], 0, + "incorrect value for stub[71], expected 0, is {}", + msg.stub[71] + ); + assert_eq!( + msg.stub[72], 0, + "incorrect value for stub[72], expected 0, is {}", + msg.stub[72] + ); + assert_eq!( + msg.stub[73], 0, + "incorrect value for stub[73], expected 0, is {}", + msg.stub[73] + ); + assert_eq!( + msg.stub[74], 8, + "incorrect value for stub[74], expected 8, is {}", + msg.stub[74] + ); + assert_eq!( + msg.stub[75], 0, + "incorrect value for stub[75], expected 0, is {}", + msg.stub[75] + ); + assert_eq!( + msg.stub[76], 0, + "incorrect value for stub[76], expected 0, is {}", + msg.stub[76] + ); + assert_eq!( + msg.stub[77], 0, + "incorrect value for stub[77], expected 0, is {}", + msg.stub[77] + ); + assert_eq!( + msg.stub[78], 9, + "incorrect value for stub[78], expected 9, is {}", + msg.stub[78] + ); + assert_eq!( + msg.stub[79], 0, + "incorrect value for stub[79], expected 0, is {}", + msg.stub[79] + ); + assert_eq!( + msg.stub[80], 0, + "incorrect value for stub[80], expected 0, is {}", + msg.stub[80] + ); + assert_eq!( + msg.stub[81], 0, + "incorrect value for stub[81], expected 0, is {}", + msg.stub[81] + ); + assert_eq!( + msg.stub[82], 10, + "incorrect value for stub[82], expected 10, is {}", + msg.stub[82] + ); + assert_eq!( + msg.stub[83], 0, + "incorrect value for stub[83], expected 0, is {}", + msg.stub[83] + ); + assert_eq!( + msg.stub[84], 0, + "incorrect value for stub[84], expected 0, is {}", + msg.stub[84] + ); + assert_eq!( + msg.stub[85], 0, + "incorrect value for stub[85], expected 0, is {}", + msg.stub[85] + ); + assert_eq!( + msg.stub[86], 11, + "incorrect value for stub[86], expected 11, is {}", + msg.stub[86] + ); + assert_eq!( + msg.stub[87], 0, + "incorrect value for stub[87], expected 0, is {}", + msg.stub[87] + ); + assert_eq!( + msg.stub[88], 0, + "incorrect value for stub[88], expected 0, is {}", + msg.stub[88] + ); + assert_eq!( + msg.stub[89], 0, + "incorrect value for stub[89], expected 0, is {}", + msg.stub[89] + ); + assert_eq!( + msg.stub[90], 12, + "incorrect value for stub[90], expected 12, is {}", + msg.stub[90] + ); + assert_eq!( + msg.stub[91], 0, + "incorrect value for stub[91], expected 0, is {}", + msg.stub[91] + ); + assert_eq!( + msg.stub[92], 0, + "incorrect value for stub[92], expected 0, is {}", + msg.stub[92] + ); + assert_eq!( + msg.stub[93], 0, + "incorrect value for stub[93], expected 0, is {}", + msg.stub[93] + ); + assert_eq!( + msg.stub[94], 13, + "incorrect value for stub[94], expected 13, is {}", + msg.stub[94] + ); + assert_eq!( + msg.stub[95], 0, + "incorrect value for stub[95], expected 0, is {}", + msg.stub[95] + ); + assert_eq!( + msg.stub[96], 0, + "incorrect value for stub[96], expected 0, is {}", + msg.stub[96] + ); + assert_eq!( + msg.stub[97], 0, + "incorrect value for stub[97], expected 0, is {}", + msg.stub[97] + ); + assert_eq!( + msg.stub[98], 14, + "incorrect value for stub[98], expected 14, is {}", + msg.stub[98] + ); + assert_eq!( + msg.stub[99], 0, + "incorrect value for stub[99], expected 0, is {}", + msg.stub[99] + ); + assert_eq!( + msg.stub[100], 0, + "incorrect value for stub[100], expected 0, is {}", + msg.stub[100] + ); + assert_eq!( + msg.stub[101], 0, + "incorrect value for stub[101], expected 0, is {}", + msg.stub[101] + ); + assert_eq!( + msg.stub[102], 15, + "incorrect value for stub[102], expected 15, is {}", + msg.stub[102] + ); + assert_eq!( + msg.stub[103], 0, + "incorrect value for stub[103], expected 0, is {}", + msg.stub[103] + ); + assert_eq!( + msg.stub[104], 0, + "incorrect value for stub[104], expected 0, is {}", + msg.stub[104] + ); + assert_eq!( + msg.stub[105], 0, + "incorrect value for stub[105], expected 0, is {}", + msg.stub[105] + ); + assert_eq!( + msg.stub[106], 16, + "incorrect value for stub[106], expected 16, is {}", + msg.stub[106] + ); + assert_eq!( + msg.stub[107], 0, + "incorrect value for stub[107], expected 0, is {}", + msg.stub[107] + ); + assert_eq!( + msg.stub[108], 0, + "incorrect value for stub[108], expected 0, is {}", + msg.stub[108] + ); + assert_eq!( + msg.stub[109], 0, + "incorrect value for stub[109], expected 0, is {}", + msg.stub[109] + ); + assert_eq!( + msg.stub[110], 17, + "incorrect value for stub[110], expected 17, is {}", + msg.stub[110] + ); + assert_eq!( + msg.stub[111], 0, + "incorrect value for stub[111], expected 0, is {}", + msg.stub[111] + ); + assert_eq!( + msg.stub[112], 0, + "incorrect value for stub[112], expected 0, is {}", + msg.stub[112] + ); + assert_eq!( + msg.stub[113], 0, + "incorrect value for stub[113], expected 0, is {}", + msg.stub[113] + ); + assert_eq!( + msg.stub[114], 18, + "incorrect value for stub[114], expected 18, is {}", + msg.stub[114] + ); + assert_eq!( + msg.stub[115], 0, + "incorrect value for stub[115], expected 0, is {}", + msg.stub[115] + ); + assert_eq!( + msg.stub[116], 0, + "incorrect value for stub[116], expected 0, is {}", + msg.stub[116] + ); + assert_eq!( + msg.stub[117], 0, + "incorrect value for stub[117], expected 0, is {}", + msg.stub[117] + ); + assert_eq!( + msg.stub[118], 19, + "incorrect value for stub[118], expected 19, is {}", + msg.stub[118] + ); + assert_eq!( + msg.stub[119], 0, + "incorrect value for stub[119], expected 0, is {}", + msg.stub[119] + ); + assert_eq!( + msg.stub[120], 0, + "incorrect value for stub[120], expected 0, is {}", + msg.stub[120] + ); + assert_eq!( + msg.stub[121], 0, + "incorrect value for stub[121], expected 0, is {}", + msg.stub[121] + ); + assert_eq!( + msg.stub[122], 20, + "incorrect value for stub[122], expected 20, is {}", + msg.stub[122] + ); + assert_eq!( + msg.stub[123], 0, + "incorrect value for stub[123], expected 0, is {}", + msg.stub[123] + ); + } + _ => panic!("Invalid message type! Expected a MsgItrf"), + }; + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} diff --git a/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_code_phase_biases_bounds.rs b/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_code_phase_biases_bounds.rs new file mode 100644 index 0000000000..fbff80aa31 --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_code_phase_biases_bounds.rs @@ -0,0 +1,206 @@ +// +// Copyright (C) 2019-2021 Swift Navigation Inc. +// Contact: https://support.swiftnav.com +// +// This source is subject to the license found in the file 'LICENSE' which must +// be be distributed together with this source. All other rights reserved. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrCodePhaseBiasesBounds.yaml by generate.py. Do not modify by hand! + +use crate::*; + +#[test] +fn test_auto_check_sbp_ssr_msg_ssr_code_phase_biases_bounds() { + { + let mut payload = Cursor::new(vec![ + 85, 236, 5, 66, 0, 31, 180, 0, 0, 0, 3, 0, 1, 2, 1, 14, 15, 1, 3, 0, 3, 39, 1, 39, 1, + 1, 3, 39, 1, 39, 1, 1, 1, 39, 1, 39, 1, 23, 113, + ]); + + // Test the round trip payload parsing + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + match &sbp_msg { + sbp::messages::Sbp::MsgSsrCodePhaseBiasesBounds(msg) => { + assert_eq!( + msg.message_type(), + 1516, + "Incorrect message type, expected 1516, is {}", + msg.message_type() + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {}", + sender_id + ); + assert_eq!( + msg.stub[0], 180, + "incorrect value for stub[0], expected 180, is {}", + msg.stub[0] + ); + assert_eq!( + msg.stub[1], 0, + "incorrect value for stub[1], expected 0, is {}", + msg.stub[1] + ); + assert_eq!( + msg.stub[2], 0, + "incorrect value for stub[2], expected 0, is {}", + msg.stub[2] + ); + assert_eq!( + msg.stub[3], 0, + "incorrect value for stub[3], expected 0, is {}", + msg.stub[3] + ); + assert_eq!( + msg.stub[4], 3, + "incorrect value for stub[4], expected 3, is {}", + msg.stub[4] + ); + assert_eq!( + msg.stub[5], 0, + "incorrect value for stub[5], expected 0, is {}", + msg.stub[5] + ); + assert_eq!( + msg.stub[6], 1, + "incorrect value for stub[6], expected 1, is {}", + msg.stub[6] + ); + assert_eq!( + msg.stub[7], 2, + "incorrect value for stub[7], expected 2, is {}", + msg.stub[7] + ); + assert_eq!( + msg.stub[8], 1, + "incorrect value for stub[8], expected 1, is {}", + msg.stub[8] + ); + assert_eq!( + msg.stub[9], 14, + "incorrect value for stub[9], expected 14, is {}", + msg.stub[9] + ); + assert_eq!( + msg.stub[10], 15, + "incorrect value for stub[10], expected 15, is {}", + msg.stub[10] + ); + assert_eq!( + msg.stub[11], 1, + "incorrect value for stub[11], expected 1, is {}", + msg.stub[11] + ); + assert_eq!( + msg.stub[12], 3, + "incorrect value for stub[12], expected 3, is {}", + msg.stub[12] + ); + assert_eq!( + msg.stub[13], 0, + "incorrect value for stub[13], expected 0, is {}", + msg.stub[13] + ); + assert_eq!( + msg.stub[14], 3, + "incorrect value for stub[14], expected 3, is {}", + msg.stub[14] + ); + assert_eq!( + msg.stub[15], 39, + "incorrect value for stub[15], expected 39, is {}", + msg.stub[15] + ); + assert_eq!( + msg.stub[16], 1, + "incorrect value for stub[16], expected 1, is {}", + msg.stub[16] + ); + assert_eq!( + msg.stub[17], 39, + "incorrect value for stub[17], expected 39, is {}", + msg.stub[17] + ); + assert_eq!( + msg.stub[18], 1, + "incorrect value for stub[18], expected 1, is {}", + msg.stub[18] + ); + assert_eq!( + msg.stub[19], 1, + "incorrect value for stub[19], expected 1, is {}", + msg.stub[19] + ); + assert_eq!( + msg.stub[20], 3, + "incorrect value for stub[20], expected 3, is {}", + msg.stub[20] + ); + assert_eq!( + msg.stub[21], 39, + "incorrect value for stub[21], expected 39, is {}", + msg.stub[21] + ); + assert_eq!( + msg.stub[22], 1, + "incorrect value for stub[22], expected 1, is {}", + msg.stub[22] + ); + assert_eq!( + msg.stub[23], 39, + "incorrect value for stub[23], expected 39, is {}", + msg.stub[23] + ); + assert_eq!( + msg.stub[24], 1, + "incorrect value for stub[24], expected 1, is {}", + msg.stub[24] + ); + assert_eq!( + msg.stub[25], 1, + "incorrect value for stub[25], expected 1, is {}", + msg.stub[25] + ); + assert_eq!( + msg.stub[26], 1, + "incorrect value for stub[26], expected 1, is {}", + msg.stub[26] + ); + assert_eq!( + msg.stub[27], 39, + "incorrect value for stub[27], expected 39, is {}", + msg.stub[27] + ); + assert_eq!( + msg.stub[28], 1, + "incorrect value for stub[28], expected 1, is {}", + msg.stub[28] + ); + assert_eq!( + msg.stub[29], 39, + "incorrect value for stub[29], expected 39, is {}", + msg.stub[29] + ); + assert_eq!( + msg.stub[30], 1, + "incorrect value for stub[30], expected 1, is {}", + msg.stub[30] + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrCodePhaseBiasesBounds"), + }; + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} diff --git a/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_gridded_correction_bounds.rs b/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_gridded_correction_bounds.rs new file mode 100644 index 0000000000..dda7f5597a --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_gridded_correction_bounds.rs @@ -0,0 +1,267 @@ +// +// Copyright (C) 2019-2021 Swift Navigation Inc. +// Contact: https://support.swiftnav.com +// +// This source is subject to the license found in the file 'LICENSE' which must +// be be distributed together with this source. All other rights reserved. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrectionBounds.yaml by generate.py. Do not modify by hand! + +use crate::*; + +#[test] +fn test_auto_check_sbp_ssr_msg_ssr_gridded_correction_bounds() { + { + let mut payload = Cursor::new(vec![ + 85, 254, 5, 66, 0, 43, 180, 0, 0, 0, 3, 0, 1, 1, 10, 0, 15, 1, 0, 10, 0, 39, 232, 3, + 244, 1, 100, 200, 150, 100, 2, 5, 10, 16, 0, 17, 18, 19, 20, 21, 6, 10, 22, 0, 23, 24, + 25, 26, 27, 112, 145, + ]); + + // Test the round trip payload parsing + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + match &sbp_msg { + sbp::messages::Sbp::MsgSsrGriddedCorrectionBounds(msg) => { + assert_eq!( + msg.message_type(), + 1534, + "Incorrect message type, expected 1534, is {}", + msg.message_type() + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {}", + sender_id + ); + assert_eq!( + msg.stub[0], 180, + "incorrect value for stub[0], expected 180, is {}", + msg.stub[0] + ); + assert_eq!( + msg.stub[1], 0, + "incorrect value for stub[1], expected 0, is {}", + msg.stub[1] + ); + assert_eq!( + msg.stub[2], 0, + "incorrect value for stub[2], expected 0, is {}", + msg.stub[2] + ); + assert_eq!( + msg.stub[3], 0, + "incorrect value for stub[3], expected 0, is {}", + msg.stub[3] + ); + assert_eq!( + msg.stub[4], 3, + "incorrect value for stub[4], expected 3, is {}", + msg.stub[4] + ); + assert_eq!( + msg.stub[5], 0, + "incorrect value for stub[5], expected 0, is {}", + msg.stub[5] + ); + assert_eq!( + msg.stub[6], 1, + "incorrect value for stub[6], expected 1, is {}", + msg.stub[6] + ); + assert_eq!( + msg.stub[7], 1, + "incorrect value for stub[7], expected 1, is {}", + msg.stub[7] + ); + assert_eq!( + msg.stub[8], 10, + "incorrect value for stub[8], expected 10, is {}", + msg.stub[8] + ); + assert_eq!( + msg.stub[9], 0, + "incorrect value for stub[9], expected 0, is {}", + msg.stub[9] + ); + assert_eq!( + msg.stub[10], 15, + "incorrect value for stub[10], expected 15, is {}", + msg.stub[10] + ); + assert_eq!( + msg.stub[11], 1, + "incorrect value for stub[11], expected 1, is {}", + msg.stub[11] + ); + assert_eq!( + msg.stub[12], 0, + "incorrect value for stub[12], expected 0, is {}", + msg.stub[12] + ); + assert_eq!( + msg.stub[13], 10, + "incorrect value for stub[13], expected 10, is {}", + msg.stub[13] + ); + assert_eq!( + msg.stub[14], 0, + "incorrect value for stub[14], expected 0, is {}", + msg.stub[14] + ); + assert_eq!( + msg.stub[15], 39, + "incorrect value for stub[15], expected 39, is {}", + msg.stub[15] + ); + assert_eq!( + msg.stub[16], 232, + "incorrect value for stub[16], expected 232, is {}", + msg.stub[16] + ); + assert_eq!( + msg.stub[17], 3, + "incorrect value for stub[17], expected 3, is {}", + msg.stub[17] + ); + assert_eq!( + msg.stub[18], 244, + "incorrect value for stub[18], expected 244, is {}", + msg.stub[18] + ); + assert_eq!( + msg.stub[19], 1, + "incorrect value for stub[19], expected 1, is {}", + msg.stub[19] + ); + assert_eq!( + msg.stub[20], 100, + "incorrect value for stub[20], expected 100, is {}", + msg.stub[20] + ); + assert_eq!( + msg.stub[21], 200, + "incorrect value for stub[21], expected 200, is {}", + msg.stub[21] + ); + assert_eq!( + msg.stub[22], 150, + "incorrect value for stub[22], expected 150, is {}", + msg.stub[22] + ); + assert_eq!( + msg.stub[23], 100, + "incorrect value for stub[23], expected 100, is {}", + msg.stub[23] + ); + assert_eq!( + msg.stub[24], 2, + "incorrect value for stub[24], expected 2, is {}", + msg.stub[24] + ); + assert_eq!( + msg.stub[25], 5, + "incorrect value for stub[25], expected 5, is {}", + msg.stub[25] + ); + assert_eq!( + msg.stub[26], 10, + "incorrect value for stub[26], expected 10, is {}", + msg.stub[26] + ); + assert_eq!( + msg.stub[27], 16, + "incorrect value for stub[27], expected 16, is {}", + msg.stub[27] + ); + assert_eq!( + msg.stub[28], 0, + "incorrect value for stub[28], expected 0, is {}", + msg.stub[28] + ); + assert_eq!( + msg.stub[29], 17, + "incorrect value for stub[29], expected 17, is {}", + msg.stub[29] + ); + assert_eq!( + msg.stub[30], 18, + "incorrect value for stub[30], expected 18, is {}", + msg.stub[30] + ); + assert_eq!( + msg.stub[31], 19, + "incorrect value for stub[31], expected 19, is {}", + msg.stub[31] + ); + assert_eq!( + msg.stub[32], 20, + "incorrect value for stub[32], expected 20, is {}", + msg.stub[32] + ); + assert_eq!( + msg.stub[33], 21, + "incorrect value for stub[33], expected 21, is {}", + msg.stub[33] + ); + assert_eq!( + msg.stub[34], 6, + "incorrect value for stub[34], expected 6, is {}", + msg.stub[34] + ); + assert_eq!( + msg.stub[35], 10, + "incorrect value for stub[35], expected 10, is {}", + msg.stub[35] + ); + assert_eq!( + msg.stub[36], 22, + "incorrect value for stub[36], expected 22, is {}", + msg.stub[36] + ); + assert_eq!( + msg.stub[37], 0, + "incorrect value for stub[37], expected 0, is {}", + msg.stub[37] + ); + assert_eq!( + msg.stub[38], 23, + "incorrect value for stub[38], expected 23, is {}", + msg.stub[38] + ); + assert_eq!( + msg.stub[39], 24, + "incorrect value for stub[39], expected 24, is {}", + msg.stub[39] + ); + assert_eq!( + msg.stub[40], 25, + "incorrect value for stub[40], expected 25, is {}", + msg.stub[40] + ); + assert_eq!( + msg.stub[41], 26, + "incorrect value for stub[41], expected 26, is {}", + msg.stub[41] + ); + assert_eq!( + msg.stub[42], 27, + "incorrect value for stub[42], expected 27, is {}", + msg.stub[42] + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrGriddedCorrectionBounds"), + }; + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} diff --git a/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_orbit_clock_bounds.rs b/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_orbit_clock_bounds.rs new file mode 100644 index 0000000000..65bd7dc225 --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_orbit_clock_bounds.rs @@ -0,0 +1,206 @@ +// +// Copyright (C) 2019-2021 Swift Navigation Inc. +// Contact: https://support.swiftnav.com +// +// This source is subject to the license found in the file 'LICENSE' which must +// be be distributed together with this source. All other rights reserved. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBounds.yaml by generate.py. Do not modify by hand! + +use crate::*; + +#[test] +fn test_auto_check_sbp_ssr_msg_ssr_orbit_clock_bounds() { + { + let mut payload = Cursor::new(vec![ + 85, 222, 5, 66, 0, 31, 180, 0, 0, 0, 3, 0, 1, 2, 3, 48, 15, 1, 2, 24, 39, 38, 37, 1, 2, + 3, 39, 1, 3, 39, 38, 37, 1, 2, 3, 39, 1, 21, 85, + ]); + + // Test the round trip payload parsing + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + match &sbp_msg { + sbp::messages::Sbp::MsgSsrOrbitClockBounds(msg) => { + assert_eq!( + msg.message_type(), + 1502, + "Incorrect message type, expected 1502, is {}", + msg.message_type() + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {}", + sender_id + ); + assert_eq!( + msg.stub[0], 180, + "incorrect value for stub[0], expected 180, is {}", + msg.stub[0] + ); + assert_eq!( + msg.stub[1], 0, + "incorrect value for stub[1], expected 0, is {}", + msg.stub[1] + ); + assert_eq!( + msg.stub[2], 0, + "incorrect value for stub[2], expected 0, is {}", + msg.stub[2] + ); + assert_eq!( + msg.stub[3], 0, + "incorrect value for stub[3], expected 0, is {}", + msg.stub[3] + ); + assert_eq!( + msg.stub[4], 3, + "incorrect value for stub[4], expected 3, is {}", + msg.stub[4] + ); + assert_eq!( + msg.stub[5], 0, + "incorrect value for stub[5], expected 0, is {}", + msg.stub[5] + ); + assert_eq!( + msg.stub[6], 1, + "incorrect value for stub[6], expected 1, is {}", + msg.stub[6] + ); + assert_eq!( + msg.stub[7], 2, + "incorrect value for stub[7], expected 2, is {}", + msg.stub[7] + ); + assert_eq!( + msg.stub[8], 3, + "incorrect value for stub[8], expected 3, is {}", + msg.stub[8] + ); + assert_eq!( + msg.stub[9], 48, + "incorrect value for stub[9], expected 48, is {}", + msg.stub[9] + ); + assert_eq!( + msg.stub[10], 15, + "incorrect value for stub[10], expected 15, is {}", + msg.stub[10] + ); + assert_eq!( + msg.stub[11], 1, + "incorrect value for stub[11], expected 1, is {}", + msg.stub[11] + ); + assert_eq!( + msg.stub[12], 2, + "incorrect value for stub[12], expected 2, is {}", + msg.stub[12] + ); + assert_eq!( + msg.stub[13], 24, + "incorrect value for stub[13], expected 24, is {}", + msg.stub[13] + ); + assert_eq!( + msg.stub[14], 39, + "incorrect value for stub[14], expected 39, is {}", + msg.stub[14] + ); + assert_eq!( + msg.stub[15], 38, + "incorrect value for stub[15], expected 38, is {}", + msg.stub[15] + ); + assert_eq!( + msg.stub[16], 37, + "incorrect value for stub[16], expected 37, is {}", + msg.stub[16] + ); + assert_eq!( + msg.stub[17], 1, + "incorrect value for stub[17], expected 1, is {}", + msg.stub[17] + ); + assert_eq!( + msg.stub[18], 2, + "incorrect value for stub[18], expected 2, is {}", + msg.stub[18] + ); + assert_eq!( + msg.stub[19], 3, + "incorrect value for stub[19], expected 3, is {}", + msg.stub[19] + ); + assert_eq!( + msg.stub[20], 39, + "incorrect value for stub[20], expected 39, is {}", + msg.stub[20] + ); + assert_eq!( + msg.stub[21], 1, + "incorrect value for stub[21], expected 1, is {}", + msg.stub[21] + ); + assert_eq!( + msg.stub[22], 3, + "incorrect value for stub[22], expected 3, is {}", + msg.stub[22] + ); + assert_eq!( + msg.stub[23], 39, + "incorrect value for stub[23], expected 39, is {}", + msg.stub[23] + ); + assert_eq!( + msg.stub[24], 38, + "incorrect value for stub[24], expected 38, is {}", + msg.stub[24] + ); + assert_eq!( + msg.stub[25], 37, + "incorrect value for stub[25], expected 37, is {}", + msg.stub[25] + ); + assert_eq!( + msg.stub[26], 1, + "incorrect value for stub[26], expected 1, is {}", + msg.stub[26] + ); + assert_eq!( + msg.stub[27], 2, + "incorrect value for stub[27], expected 2, is {}", + msg.stub[27] + ); + assert_eq!( + msg.stub[28], 3, + "incorrect value for stub[28], expected 3, is {}", + msg.stub[28] + ); + assert_eq!( + msg.stub[29], 39, + "incorrect value for stub[29], expected 39, is {}", + msg.stub[29] + ); + assert_eq!( + msg.stub[30], 1, + "incorrect value for stub[30], expected 1, is {}", + msg.stub[30] + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrOrbitClockBounds"), + }; + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} diff --git a/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_orbit_clock_bounds_degradation.rs b/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_orbit_clock_bounds_degradation.rs new file mode 100644 index 0000000000..cec3090bfa --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_orbit_clock_bounds_degradation.rs @@ -0,0 +1,191 @@ +// +// Copyright (C) 2019-2021 Swift Navigation Inc. +// Contact: https://support.swiftnav.com +// +// This source is subject to the license found in the file 'LICENSE' which must +// be be distributed together with this source. All other rights reserved. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBoundsDegradation.yaml by generate.py. Do not modify by hand! + +use crate::*; + +#[test] +fn test_auto_check_sbp_ssr_msg_ssr_orbit_clock_bounds_degradation() { + { + let mut payload = Cursor::new(vec![ + 85, 223, 5, 66, 0, 28, 180, 0, 0, 0, 3, 0, 1, 2, 3, 48, 15, 1, 10, 0, 0, 0, 0, 0, 0, 0, + 200, 199, 198, 197, 196, 195, 194, 193, 200, 117, + ]); + + // Test the round trip payload parsing + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + match &sbp_msg { + sbp::messages::Sbp::MsgSsrOrbitClockBoundsDegradation(msg) => { + assert_eq!( + msg.message_type(), + 1503, + "Incorrect message type, expected 1503, is {}", + msg.message_type() + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {}", + sender_id + ); + assert_eq!( + msg.stub[0], 180, + "incorrect value for stub[0], expected 180, is {}", + msg.stub[0] + ); + assert_eq!( + msg.stub[1], 0, + "incorrect value for stub[1], expected 0, is {}", + msg.stub[1] + ); + assert_eq!( + msg.stub[2], 0, + "incorrect value for stub[2], expected 0, is {}", + msg.stub[2] + ); + assert_eq!( + msg.stub[3], 0, + "incorrect value for stub[3], expected 0, is {}", + msg.stub[3] + ); + assert_eq!( + msg.stub[4], 3, + "incorrect value for stub[4], expected 3, is {}", + msg.stub[4] + ); + assert_eq!( + msg.stub[5], 0, + "incorrect value for stub[5], expected 0, is {}", + msg.stub[5] + ); + assert_eq!( + msg.stub[6], 1, + "incorrect value for stub[6], expected 1, is {}", + msg.stub[6] + ); + assert_eq!( + msg.stub[7], 2, + "incorrect value for stub[7], expected 2, is {}", + msg.stub[7] + ); + assert_eq!( + msg.stub[8], 3, + "incorrect value for stub[8], expected 3, is {}", + msg.stub[8] + ); + assert_eq!( + msg.stub[9], 48, + "incorrect value for stub[9], expected 48, is {}", + msg.stub[9] + ); + assert_eq!( + msg.stub[10], 15, + "incorrect value for stub[10], expected 15, is {}", + msg.stub[10] + ); + assert_eq!( + msg.stub[11], 1, + "incorrect value for stub[11], expected 1, is {}", + msg.stub[11] + ); + assert_eq!( + msg.stub[12], 10, + "incorrect value for stub[12], expected 10, is {}", + msg.stub[12] + ); + assert_eq!( + msg.stub[13], 0, + "incorrect value for stub[13], expected 0, is {}", + msg.stub[13] + ); + assert_eq!( + msg.stub[14], 0, + "incorrect value for stub[14], expected 0, is {}", + msg.stub[14] + ); + assert_eq!( + msg.stub[15], 0, + "incorrect value for stub[15], expected 0, is {}", + msg.stub[15] + ); + assert_eq!( + msg.stub[16], 0, + "incorrect value for stub[16], expected 0, is {}", + msg.stub[16] + ); + assert_eq!( + msg.stub[17], 0, + "incorrect value for stub[17], expected 0, is {}", + msg.stub[17] + ); + assert_eq!( + msg.stub[18], 0, + "incorrect value for stub[18], expected 0, is {}", + msg.stub[18] + ); + assert_eq!( + msg.stub[19], 0, + "incorrect value for stub[19], expected 0, is {}", + msg.stub[19] + ); + assert_eq!( + msg.stub[20], 200, + "incorrect value for stub[20], expected 200, is {}", + msg.stub[20] + ); + assert_eq!( + msg.stub[21], 199, + "incorrect value for stub[21], expected 199, is {}", + msg.stub[21] + ); + assert_eq!( + msg.stub[22], 198, + "incorrect value for stub[22], expected 198, is {}", + msg.stub[22] + ); + assert_eq!( + msg.stub[23], 197, + "incorrect value for stub[23], expected 197, is {}", + msg.stub[23] + ); + assert_eq!( + msg.stub[24], 196, + "incorrect value for stub[24], expected 196, is {}", + msg.stub[24] + ); + assert_eq!( + msg.stub[25], 195, + "incorrect value for stub[25], expected 195, is {}", + msg.stub[25] + ); + assert_eq!( + msg.stub[26], 194, + "incorrect value for stub[26], expected 194, is {}", + msg.stub[26] + ); + assert_eq!( + msg.stub[27], 193, + "incorrect value for stub[27], expected 193, is {}", + msg.stub[27] + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrOrbitClockBoundsDegradation"), + }; + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} diff --git a/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_stec_correction.rs b/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_stec_correction.rs new file mode 100644 index 0000000000..59fec93822 --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_stec_correction.rs @@ -0,0 +1,241 @@ +// +// Copyright (C) 2019-2021 Swift Navigation Inc. +// Contact: https://support.swiftnav.com +// +// This source is subject to the license found in the file 'LICENSE' which must +// be be distributed together with this source. All other rights reserved. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrStecCorrection.yaml by generate.py. Do not modify by hand! + +use crate::*; + +#[test] +fn test_auto_check_sbp_ssr_msg_ssr_stec_correction() { + { + let mut payload = Cursor::new(vec![ + 85, 253, 5, 66, 0, 38, 180, 0, 0, 0, 3, 0, 1, 1, 10, 0, 15, 1, 0, 10, 0, 2, 1, 1, 1, + 63, 0, 62, 0, 61, 0, 60, 0, 31, 15, 5, 63, 0, 64, 0, 65, 0, 66, 0, 119, 50, + ]); + + // Test the round trip payload parsing + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + match &sbp_msg { + sbp::messages::Sbp::MsgSsrStecCorrection(msg) => { + assert_eq!( + msg.message_type(), + 1533, + "Incorrect message type, expected 1533, is {}", + msg.message_type() + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {}", + sender_id + ); + assert_eq!( + msg.stub[0], 180, + "incorrect value for stub[0], expected 180, is {}", + msg.stub[0] + ); + assert_eq!( + msg.stub[1], 0, + "incorrect value for stub[1], expected 0, is {}", + msg.stub[1] + ); + assert_eq!( + msg.stub[2], 0, + "incorrect value for stub[2], expected 0, is {}", + msg.stub[2] + ); + assert_eq!( + msg.stub[3], 0, + "incorrect value for stub[3], expected 0, is {}", + msg.stub[3] + ); + assert_eq!( + msg.stub[4], 3, + "incorrect value for stub[4], expected 3, is {}", + msg.stub[4] + ); + assert_eq!( + msg.stub[5], 0, + "incorrect value for stub[5], expected 0, is {}", + msg.stub[5] + ); + assert_eq!( + msg.stub[6], 1, + "incorrect value for stub[6], expected 1, is {}", + msg.stub[6] + ); + assert_eq!( + msg.stub[7], 1, + "incorrect value for stub[7], expected 1, is {}", + msg.stub[7] + ); + assert_eq!( + msg.stub[8], 10, + "incorrect value for stub[8], expected 10, is {}", + msg.stub[8] + ); + assert_eq!( + msg.stub[9], 0, + "incorrect value for stub[9], expected 0, is {}", + msg.stub[9] + ); + assert_eq!( + msg.stub[10], 15, + "incorrect value for stub[10], expected 15, is {}", + msg.stub[10] + ); + assert_eq!( + msg.stub[11], 1, + "incorrect value for stub[11], expected 1, is {}", + msg.stub[11] + ); + assert_eq!( + msg.stub[12], 0, + "incorrect value for stub[12], expected 0, is {}", + msg.stub[12] + ); + assert_eq!( + msg.stub[13], 10, + "incorrect value for stub[13], expected 10, is {}", + msg.stub[13] + ); + assert_eq!( + msg.stub[14], 0, + "incorrect value for stub[14], expected 0, is {}", + msg.stub[14] + ); + assert_eq!( + msg.stub[15], 2, + "incorrect value for stub[15], expected 2, is {}", + msg.stub[15] + ); + assert_eq!( + msg.stub[16], 1, + "incorrect value for stub[16], expected 1, is {}", + msg.stub[16] + ); + assert_eq!( + msg.stub[17], 1, + "incorrect value for stub[17], expected 1, is {}", + msg.stub[17] + ); + assert_eq!( + msg.stub[18], 1, + "incorrect value for stub[18], expected 1, is {}", + msg.stub[18] + ); + assert_eq!( + msg.stub[19], 63, + "incorrect value for stub[19], expected 63, is {}", + msg.stub[19] + ); + assert_eq!( + msg.stub[20], 0, + "incorrect value for stub[20], expected 0, is {}", + msg.stub[20] + ); + assert_eq!( + msg.stub[21], 62, + "incorrect value for stub[21], expected 62, is {}", + msg.stub[21] + ); + assert_eq!( + msg.stub[22], 0, + "incorrect value for stub[22], expected 0, is {}", + msg.stub[22] + ); + assert_eq!( + msg.stub[23], 61, + "incorrect value for stub[23], expected 61, is {}", + msg.stub[23] + ); + assert_eq!( + msg.stub[24], 0, + "incorrect value for stub[24], expected 0, is {}", + msg.stub[24] + ); + assert_eq!( + msg.stub[25], 60, + "incorrect value for stub[25], expected 60, is {}", + msg.stub[25] + ); + assert_eq!( + msg.stub[26], 0, + "incorrect value for stub[26], expected 0, is {}", + msg.stub[26] + ); + assert_eq!( + msg.stub[27], 31, + "incorrect value for stub[27], expected 31, is {}", + msg.stub[27] + ); + assert_eq!( + msg.stub[28], 15, + "incorrect value for stub[28], expected 15, is {}", + msg.stub[28] + ); + assert_eq!( + msg.stub[29], 5, + "incorrect value for stub[29], expected 5, is {}", + msg.stub[29] + ); + assert_eq!( + msg.stub[30], 63, + "incorrect value for stub[30], expected 63, is {}", + msg.stub[30] + ); + assert_eq!( + msg.stub[31], 0, + "incorrect value for stub[31], expected 0, is {}", + msg.stub[31] + ); + assert_eq!( + msg.stub[32], 64, + "incorrect value for stub[32], expected 64, is {}", + msg.stub[32] + ); + assert_eq!( + msg.stub[33], 0, + "incorrect value for stub[33], expected 0, is {}", + msg.stub[33] + ); + assert_eq!( + msg.stub[34], 65, + "incorrect value for stub[34], expected 65, is {}", + msg.stub[34] + ); + assert_eq!( + msg.stub[35], 0, + "incorrect value for stub[35], expected 0, is {}", + msg.stub[35] + ); + assert_eq!( + msg.stub[36], 66, + "incorrect value for stub[36], expected 66, is {}", + msg.stub[36] + ); + assert_eq!( + msg.stub[37], 0, + "incorrect value for stub[37], expected 0, is {}", + msg.stub[37] + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrStecCorrection"), + }; + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} diff --git a/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_tile_definition.rs b/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_tile_definition.rs new file mode 100644 index 0000000000..fd4631733a --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_ssr_msg_ssr_tile_definition.rs @@ -0,0 +1,176 @@ +// +// Copyright (C) 2019-2021 Swift Navigation Inc. +// Contact: https://support.swiftnav.com +// +// This source is subject to the license found in the file 'LICENSE' which must +// be be distributed together with this source. All other rights reserved. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrTileDefinition.yaml by generate.py. Do not modify by hand! + +use crate::*; + +#[test] +fn test_auto_check_sbp_ssr_msg_ssr_tile_definition() { + { + let mut payload = Cursor::new(vec![ + 85, 247, 5, 66, 0, 25, 31, 0, 1, 0, 2, 0, 4, 0, 8, 0, 16, 0, 32, 0, 64, 0, 128, 210, 2, + 150, 73, 0, 0, 0, 0, 214, 71, + ]); + + // Test the round trip payload parsing + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + match &sbp_msg { + sbp::messages::Sbp::MsgSsrTileDefinition(msg) => { + assert_eq!( + msg.message_type(), + 1527, + "Incorrect message type, expected 1527, is {}", + msg.message_type() + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {}", + sender_id + ); + assert_eq!( + msg.stub[0], 31, + "incorrect value for stub[0], expected 31, is {}", + msg.stub[0] + ); + assert_eq!( + msg.stub[1], 0, + "incorrect value for stub[1], expected 0, is {}", + msg.stub[1] + ); + assert_eq!( + msg.stub[2], 1, + "incorrect value for stub[2], expected 1, is {}", + msg.stub[2] + ); + assert_eq!( + msg.stub[3], 0, + "incorrect value for stub[3], expected 0, is {}", + msg.stub[3] + ); + assert_eq!( + msg.stub[4], 2, + "incorrect value for stub[4], expected 2, is {}", + msg.stub[4] + ); + assert_eq!( + msg.stub[5], 0, + "incorrect value for stub[5], expected 0, is {}", + msg.stub[5] + ); + assert_eq!( + msg.stub[6], 4, + "incorrect value for stub[6], expected 4, is {}", + msg.stub[6] + ); + assert_eq!( + msg.stub[7], 0, + "incorrect value for stub[7], expected 0, is {}", + msg.stub[7] + ); + assert_eq!( + msg.stub[8], 8, + "incorrect value for stub[8], expected 8, is {}", + msg.stub[8] + ); + assert_eq!( + msg.stub[9], 0, + "incorrect value for stub[9], expected 0, is {}", + msg.stub[9] + ); + assert_eq!( + msg.stub[10], 16, + "incorrect value for stub[10], expected 16, is {}", + msg.stub[10] + ); + assert_eq!( + msg.stub[11], 0, + "incorrect value for stub[11], expected 0, is {}", + msg.stub[11] + ); + assert_eq!( + msg.stub[12], 32, + "incorrect value for stub[12], expected 32, is {}", + msg.stub[12] + ); + assert_eq!( + msg.stub[13], 0, + "incorrect value for stub[13], expected 0, is {}", + msg.stub[13] + ); + assert_eq!( + msg.stub[14], 64, + "incorrect value for stub[14], expected 64, is {}", + msg.stub[14] + ); + assert_eq!( + msg.stub[15], 0, + "incorrect value for stub[15], expected 0, is {}", + msg.stub[15] + ); + assert_eq!( + msg.stub[16], 128, + "incorrect value for stub[16], expected 128, is {}", + msg.stub[16] + ); + assert_eq!( + msg.stub[17], 210, + "incorrect value for stub[17], expected 210, is {}", + msg.stub[17] + ); + assert_eq!( + msg.stub[18], 2, + "incorrect value for stub[18], expected 2, is {}", + msg.stub[18] + ); + assert_eq!( + msg.stub[19], 150, + "incorrect value for stub[19], expected 150, is {}", + msg.stub[19] + ); + assert_eq!( + msg.stub[20], 73, + "incorrect value for stub[20], expected 73, is {}", + msg.stub[20] + ); + assert_eq!( + msg.stub[21], 0, + "incorrect value for stub[21], expected 0, is {}", + msg.stub[21] + ); + assert_eq!( + msg.stub[22], 0, + "incorrect value for stub[22], expected 0, is {}", + msg.stub[22] + ); + assert_eq!( + msg.stub[23], 0, + "incorrect value for stub[23], expected 0, is {}", + msg.stub[23] + ); + assert_eq!( + msg.stub[24], 0, + "incorrect value for stub[24], expected 0, is {}", + msg.stub[24] + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrTileDefinition"), + }; + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} diff --git a/rust/sbp/tests/integration/main.rs b/rust/sbp/tests/integration/main.rs index 1ecb30220e..1ccc5b3dbc 100644 --- a/rust/sbp/tests/integration/main.rs +++ b/rust/sbp/tests/integration/main.rs @@ -18,6 +18,12 @@ mod auto_check_sbp_ext_events_msg_ext_event; mod auto_check_sbp_file_io_msg_fileio_write_resp; mod auto_check_sbp_imu_msg_imu_aux; mod auto_check_sbp_imu_msg_imu_raw; +mod auto_check_sbp_integrity_msg_ssr_flag_high_level; +mod auto_check_sbp_integrity_msg_ssr_flag_iono_grid_point_sat_los; +mod auto_check_sbp_integrity_msg_ssr_flag_iono_grid_points; +mod auto_check_sbp_integrity_msg_ssr_flag_iono_tile_sat_los; +mod auto_check_sbp_integrity_msg_ssr_flag_satellites; +mod auto_check_sbp_integrity_msg_ssr_flag_tropo_grid_points; mod auto_check_sbp_logging_msg_fwd; mod auto_check_sbp_logging_msg_log; mod auto_check_sbp_logging_msg_print_dep; @@ -28,9 +34,11 @@ mod auto_check_sbp_navigation_msg_baseline_ned; mod auto_check_sbp_navigation_msg_baseline_ned_dep_a; mod auto_check_sbp_navigation_msg_dops; mod auto_check_sbp_navigation_msg_dops_dep_a; +mod auto_check_sbp_navigation_msg_gps_leap_second; mod auto_check_sbp_navigation_msg_gps_time; mod auto_check_sbp_navigation_msg_gps_time_dep_a; mod auto_check_sbp_navigation_msg_gps_time_gnss; +mod auto_check_sbp_navigation_msg_itrf; mod auto_check_sbp_navigation_msg_pos_ecef; mod auto_check_sbp_navigation_msg_pos_ecef_cov; mod auto_check_sbp_navigation_msg_pos_ecef_cov_gnss; @@ -82,6 +90,12 @@ mod auto_check_sbp_piksi_msg_uart_state_dep_a; mod auto_check_sbp_sbas_msg_sbas_raw; mod auto_check_sbp_settings_msg_settings_read_by_index_done; mod auto_check_sbp_settings_msg_settings_read_by_index_resp; +mod auto_check_sbp_ssr_msg_ssr_code_phase_biases_bounds; +mod auto_check_sbp_ssr_msg_ssr_gridded_correction_bounds; +mod auto_check_sbp_ssr_msg_ssr_orbit_clock_bounds; +mod auto_check_sbp_ssr_msg_ssr_orbit_clock_bounds_degradation; +mod auto_check_sbp_ssr_msg_ssr_stec_correction; +mod auto_check_sbp_ssr_msg_ssr_tile_definition; mod auto_check_sbp_system_msg_dgnss_status; mod auto_check_sbp_system_msg_group_meta; mod auto_check_sbp_system_msg_heartbeat; diff --git a/sbpjson/elm/SbpJson.elm b/sbpjson/elm/SbpJson.elm index 78427fb99c..9a2505678b 100644 --- a/sbpjson/elm/SbpJson.elm +++ b/sbpjson/elm/SbpJson.elm @@ -5,7 +5,7 @@ -- add these imports -- -- import Json.Decode exposing (decodeString)`); --- import SbpJson exposing (acqSvProfile, almanacCommonContent, carrierPhase, codeBiasesContent, doppler, ephemerisCommonContent, estimatedHorizontalErrorEllipse, gnssInputType, gnssCapb, gnssSignal, gpsTime, gpsTimeSEC, gridElement, gridElementNoStd, griddedCorrectionHeader, imuInputType, latency, measurementState, msgAcqResult, msgAcqSvProfile, msgAgeCorrections, msgAlmanac, msgAlmanacGPS, msgAlmanacGlo, msgAngularRate, msgBasePosECEF, msgBasePosLLH, msgBaselineECEF, msgBaselineHeading, msgBaselineNED, msgBootloaderHandshakeReq, msgBootloaderHandshakeResp, msgBootloaderJumpToApp, msgCellModemStatus, msgCommandOutput, msgCommandReq, msgCommandResp, msgCsacTelemetry, msgCsacTelemetryLabels, msgCwResults, msgCwStart, msgDeviceMonitor, msgDgnssStatus, msgDops, msgEphemerisBds, msgEphemerisGPS, msgEphemerisGal, msgEphemerisGlo, msgEphemerisQzss, msgEphemerisSbas, msgEXTEvent, msgFileioConfigReq, msgFileioConfigResp, msgFileioReadDirReq, msgFileioReadDirResp, msgFileioReadReq, msgFileioReadResp, msgFileioRemove, msgFileioWriteReq, msgFileioWriteResp, msgFlashDone, msgFlashErase, msgFlashProgram, msgFlashReadReq, msgFlashReadResp, msgFrontEndGain, msgFwd, msgGPSTime, msgGPSTimeGnss, msgGloBiases, msgGnssCapb, msgGnssTimeOffset, msgGroupDelay, msgGroupMeta, msgHeartbeat, msgIarState, msgImuAux, msgImuRaw, msgInsStatus, msgInsUpdates, msgIono, msgLinuxCPUState, msgLinuxMemState, msgLinuxProcessFdCount, msgLinuxProcessFdSummary, msgLinuxProcessSocketCounts, msgLinuxProcessSocketQueues, msgLinuxSocketUsage, msgLinuxSysState, msgLog, msgM25FlashWriteStatus, msgMagRaw, msgMaskSatellite, msgMeasurementState, msgNapDeviceDnaReq, msgNapDeviceDnaResp, msgNdbEvent, msgNetworkBandwidthUsage, msgNetworkStateReq, msgNetworkStateResp, msgObs, msgOdometry, msgOrientEuler, msgOrientQuat, msgOsr, msgPosECEF, msgPosECEFCov, msgPosECEFCovGnss, msgPosECEFGnss, msgPosLLH, msgPosLLHAcc, msgPosLLHCov, msgPosLLHCovGnss, msgPosLLHGnss, msgPpsTime, msgProtectionLevel, msgReset, msgResetFilters, msgSbasRaw, msgSensorAidEvent, msgSetTime, msgSettingsReadByIndexDone, msgSettingsReadByIndexReq, msgSettingsReadByIndexResp, msgSettingsReadReq, msgSettingsReadResp, msgSettingsRegister, msgSettingsRegisterResp, msgSettingsSave, msgSettingsWrite, msgSettingsWriteResp, msgSolnMeta, msgSpecan, msgSsrCodeBiases, msgSsrGriddedCorrection, msgSsrOrbitClock, msgSsrPhaseBiases, msgSsrSatelliteApc, msgSsrStecCorrection, msgSsrTileDefinition, msgStartup, msgStatusJournal, msgStatusReport, msgStmFlashLockSector, msgStmFlashUnlockSector, msgStmUniqueIDReq, msgStmUniqueIDResp, msgSvAzEl, msgThreadState, msgTrackingIq, msgTrackingState, msgUARTState, msgUserData, msgUTCTime, msgUTCTimeGnss, msgVelBody, msgVelCog, msgVelECEF, msgVelECEFCov, msgVelECEFCovGnss, msgVelECEFGnss, msgVelNED, msgVelNEDCov, msgVelNEDCovGnss, msgVelNEDGnss, msgWheeltick, networkUsage, observationHeader, odoInputType, packedObsContent, packedOsrContent, period, phaseBiasesContent, stecHeader, stecResidual, stecResidualNoStd, stecSatElement, satelliteAPC, solutionInputType, statusJournalItem, subSystemReport, svAzEl, svID, trackingChannelCorrelation, trackingChannelState, troposphericDelayCorrection, troposphericDelayCorrectionNoStd, uartChannel) +-- import SbpJson exposing (acqSvProfile, almanacCommonContent, carrierPhase, codeBiasesContent, doppler, ephemerisCommonContent, estimatedHorizontalErrorEllipse, gnssInputType, gnssCapb, gnssSignal, gpsTime, gpsTimeSEC, gridElement, gridElementNoStd, griddedCorrectionHeader, imuInputType, latency, measurementState, msgAcqResult, msgAcqSvProfile, msgAgeCorrections, msgAlmanac, msgAlmanacGPS, msgAlmanacGlo, msgAngularRate, msgBasePosECEF, msgBasePosLLH, msgBaselineECEF, msgBaselineHeading, msgBaselineNED, msgBootloaderHandshakeReq, msgBootloaderHandshakeResp, msgBootloaderJumpToApp, msgCellModemStatus, msgCommandOutput, msgCommandReq, msgCommandResp, msgCsacTelemetry, msgCsacTelemetryLabels, msgCwResults, msgCwStart, msgDeviceMonitor, msgDgnssStatus, msgDops, msgEphemerisBds, msgEphemerisGPS, msgEphemerisGal, msgEphemerisGlo, msgEphemerisQzss, msgEphemerisSbas, msgEXTEvent, msgFileioConfigReq, msgFileioConfigResp, msgFileioReadDirReq, msgFileioReadDirResp, msgFileioReadReq, msgFileioReadResp, msgFileioRemove, msgFileioWriteReq, msgFileioWriteResp, msgFlashDone, msgFlashErase, msgFlashProgram, msgFlashReadReq, msgFlashReadResp, msgFrontEndGain, msgFwd, msgGPSLeapSecond, msgGPSTime, msgGPSTimeGnss, msgGloBiases, msgGnssCapb, msgGnssTimeOffset, msgGroupDelay, msgGroupMeta, msgHeartbeat, msgIarState, msgImuAux, msgImuRaw, msgInsStatus, msgInsUpdates, msgIono, msgItrf, msgLinuxCPUState, msgLinuxMemState, msgLinuxProcessFdCount, msgLinuxProcessFdSummary, msgLinuxProcessSocketCounts, msgLinuxProcessSocketQueues, msgLinuxSocketUsage, msgLinuxSysState, msgLog, msgM25FlashWriteStatus, msgMagRaw, msgMaskSatellite, msgMeasurementState, msgNapDeviceDnaReq, msgNapDeviceDnaResp, msgNdbEvent, msgNetworkBandwidthUsage, msgNetworkStateReq, msgNetworkStateResp, msgObs, msgOdometry, msgOrientEuler, msgOrientQuat, msgOsr, msgPosECEF, msgPosECEFCov, msgPosECEFCovGnss, msgPosECEFGnss, msgPosLLH, msgPosLLHAcc, msgPosLLHCov, msgPosLLHCovGnss, msgPosLLHGnss, msgPpsTime, msgProtectionLevel, msgReset, msgResetFilters, msgSbasRaw, msgSensorAidEvent, msgSetTime, msgSettingsReadByIndexDone, msgSettingsReadByIndexReq, msgSettingsReadByIndexResp, msgSettingsReadReq, msgSettingsReadResp, msgSettingsRegister, msgSettingsRegisterResp, msgSettingsSave, msgSettingsWrite, msgSettingsWriteResp, msgSolnMeta, msgSpecan, msgSsrCodeBiases, msgSsrCodePhaseBiasesBounds, msgSsrFlagHighLevel, msgSsrFlagIonoGridPointSatLos, msgSsrFlagIonoGridPoints, msgSsrFlagIonoTileSatLos, msgSsrFlagSatellites, msgSsrFlagTropoGridPoints, msgSsrGriddedCorrection, msgSsrGriddedCorrectionBounds, msgSsrOrbitClock, msgSsrOrbitClockBounds, msgSsrOrbitClockBoundsDegradation, msgSsrPhaseBiases, msgSsrSatelliteApc, msgSsrStecCorrection, msgSsrTileDefinition, msgStartup, msgStatusJournal, msgStatusReport, msgStmFlashLockSector, msgStmFlashUnlockSector, msgStmUniqueIDReq, msgStmUniqueIDResp, msgSvAzEl, msgThreadState, msgTrackingIq, msgTrackingState, msgUARTState, msgUserData, msgUTCTime, msgUTCTimeGnss, msgVelBody, msgVelCog, msgVelECEF, msgVelECEFCov, msgVelECEFCovGnss, msgVelECEFGnss, msgVelNED, msgVelNEDCov, msgVelNEDCovGnss, msgVelNEDGnss, msgWheeltick, networkUsage, observationHeader, odoInputType, packedObsContent, packedOsrContent, period, phaseBiasesContent, stecHeader, stecResidual, stecResidualNoStd, stecSatElement, satelliteAPC, solutionInputType, statusJournalItem, subSystemReport, svAzEl, svID, trackingChannelCorrelation, trackingChannelState, troposphericDelayCorrection, troposphericDelayCorrectionNoStd, uartChannel) -- -- and you're off to the races with -- @@ -76,6 +76,7 @@ -- decodeString msgFlashReadResp myJsonString -- decodeString msgFrontEndGain myJsonString -- decodeString msgFwd myJsonString +-- decodeString msgGPSLeapSecond myJsonString -- decodeString msgGPSTime myJsonString -- decodeString msgGPSTimeGnss myJsonString -- decodeString msgGloBiases myJsonString @@ -90,6 +91,7 @@ -- decodeString msgInsStatus myJsonString -- decodeString msgInsUpdates myJsonString -- decodeString msgIono myJsonString +-- decodeString msgItrf myJsonString -- decodeString msgLinuxCPUState myJsonString -- decodeString msgLinuxMemState myJsonString -- decodeString msgLinuxProcessFdCount myJsonString @@ -143,8 +145,18 @@ -- decodeString msgSolnMeta myJsonString -- decodeString msgSpecan myJsonString -- decodeString msgSsrCodeBiases myJsonString +-- decodeString msgSsrCodePhaseBiasesBounds myJsonString +-- decodeString msgSsrFlagHighLevel myJsonString +-- decodeString msgSsrFlagIonoGridPointSatLos myJsonString +-- decodeString msgSsrFlagIonoGridPoints myJsonString +-- decodeString msgSsrFlagIonoTileSatLos myJsonString +-- decodeString msgSsrFlagSatellites myJsonString +-- decodeString msgSsrFlagTropoGridPoints myJsonString -- decodeString msgSsrGriddedCorrection myJsonString +-- decodeString msgSsrGriddedCorrectionBounds myJsonString -- decodeString msgSsrOrbitClock myJsonString +-- decodeString msgSsrOrbitClockBounds myJsonString +-- decodeString msgSsrOrbitClockBoundsDegradation myJsonString -- decodeString msgSsrPhaseBiases myJsonString -- decodeString msgSsrSatelliteApc myJsonString -- decodeString msgSsrStecCorrection myJsonString @@ -400,6 +412,9 @@ module SbpJson exposing , MsgFwd , msgFwdToString , msgFwd + , MsgGPSLeapSecond + , msgGPSLeapSecondToString + , msgGPSLeapSecond , MsgGPSTime , msgGPSTimeToString , msgGPSTime @@ -442,6 +457,9 @@ module SbpJson exposing , MsgIono , msgIonoToString , msgIono + , MsgItrf + , msgItrfToString + , msgItrf , MsgLinuxCPUState , msgLinuxCPUStateToString , msgLinuxCPUState @@ -601,12 +619,42 @@ module SbpJson exposing , MsgSsrCodeBiases , msgSsrCodeBiasesToString , msgSsrCodeBiases + , MsgSsrCodePhaseBiasesBounds + , msgSsrCodePhaseBiasesBoundsToString + , msgSsrCodePhaseBiasesBounds + , MsgSsrFlagHighLevel + , msgSsrFlagHighLevelToString + , msgSsrFlagHighLevel + , MsgSsrFlagIonoGridPointSatLos + , msgSsrFlagIonoGridPointSatLosToString + , msgSsrFlagIonoGridPointSatLos + , MsgSsrFlagIonoGridPoints + , msgSsrFlagIonoGridPointsToString + , msgSsrFlagIonoGridPoints + , MsgSsrFlagIonoTileSatLos + , msgSsrFlagIonoTileSatLosToString + , msgSsrFlagIonoTileSatLos + , MsgSsrFlagSatellites + , msgSsrFlagSatellitesToString + , msgSsrFlagSatellites + , MsgSsrFlagTropoGridPoints + , msgSsrFlagTropoGridPointsToString + , msgSsrFlagTropoGridPoints , MsgSsrGriddedCorrection , msgSsrGriddedCorrectionToString , msgSsrGriddedCorrection + , MsgSsrGriddedCorrectionBounds + , msgSsrGriddedCorrectionBoundsToString + , msgSsrGriddedCorrectionBounds , MsgSsrOrbitClock , msgSsrOrbitClockToString , msgSsrOrbitClock + , MsgSsrOrbitClockBounds + , msgSsrOrbitClockBoundsToString + , msgSsrOrbitClockBounds + , MsgSsrOrbitClockBoundsDegradation + , msgSsrOrbitClockBoundsDegradationToString + , msgSsrOrbitClockBoundsDegradation , MsgSsrPhaseBiases , msgSsrPhaseBiasesToString , msgSsrPhaseBiases @@ -1481,6 +1529,13 @@ type alias MsgFwd = , source : Int } +{-| Emulates the GPS CNAV message, reserving bytes for future broadcast of the drift model +parameters. +-} +type alias MsgGPSLeapSecond = + { stub : Array Int + } + {-| This message reports the GPS time, representing the time since the GPS epoch began on midnight January 6, 1980 UTC. GPS time counts the weeks and seconds of the week. The weeks begin at the Saturday/Sunday transition. GPS week 0 began at the beginning of the @@ -1671,6 +1726,10 @@ type alias MsgIono = , tNmct : GpsTimeSEC } +type alias MsgItrf = + { stub : Array Int + } + {-| This message indicates the process state of the top 10 heaviest consumers of CPU on the system, including a timestamp. -} @@ -2405,6 +2464,34 @@ type alias CodeBiasesContent = , value : Int } +type alias MsgSsrCodePhaseBiasesBounds = + { stub : Array Int + } + +type alias MsgSsrFlagHighLevel = + { stub : Array Int + } + +type alias MsgSsrFlagIonoGridPointSatLos = + { stub : Array Int + } + +type alias MsgSsrFlagIonoGridPoints = + { stub : Array Int + } + +type alias MsgSsrFlagIonoTileSatLos = + { stub : Array Int + } + +type alias MsgSsrFlagSatellites = + { stub : Array Int + } + +type alias MsgSsrFlagTropoGridPoints = + { stub : Array Int + } + {-| STEC residuals are per space vehicle, troposphere is not., , It is typically equivalent to the QZSS CLAS Sub Type 9 messages. @@ -2430,6 +2517,10 @@ type alias GriddedCorrectionHeader = , updateInterval : Int } +type alias MsgSsrGriddedCorrectionBounds = + { stub : Array Int + } + {-| The precise orbit and clock correction message is to be applied as a delta correction to broadcast ephemeris and is an equivalent to the 1060 /1066 RTCM message types. -} @@ -2450,6 +2541,14 @@ type alias MsgSsrOrbitClock = , updateInterval : Int } +type alias MsgSsrOrbitClockBounds = + { stub : Array Int + } + +type alias MsgSsrOrbitClockBoundsDegradation = + { stub : Array Int + } + {-| The precise phase biases message contains the biases to be added to the carrier phase of the corresponding signal to get corrected carrier phase measurement, as well as the satellite yaw angle to be applied to compute the phase wind-up correction. It is @@ -2491,35 +2590,8 @@ type alias SatelliteAPC = , svn : Int } -{-| The Slant Total Electron Content per space vehicle, given as polynomial approximation for -a given tile. This should be combined with the MSG_SSR_GRIDDED_CORRECTION message to get -the state space representation of the atmospheric delay., -, -It is typically equivalent to the QZSS CLAS Sub Type 8 messages. --} type alias MsgSsrStecCorrection = - { header : STECHeader - , stecSatList : Array STECSatElement - } - -{-| A full set of STEC information will likely span multiple SBP messages, since SBP message -a limited to 255 bytes. The header is used to tie multiple SBP messages into a sequence. --} -type alias STECHeader = - { iodAtmo : Int - , numMsgs : Int - , seqNum : Int - , tileID : Int - , tileSetID : Int - , time : GpsTimeSEC - , updateInterval : Int - } - -{-| STEC polynomial for the given satellite. -} -type alias STECSatElement = - { stecCoeff : Array Int - , stecQualityIndicator : Int - , svID : SvID + { stub : Array Int } {-| Provides the correction point coordinates for the atmospheric correction values in the @@ -2530,15 +2602,7 @@ GNSS-SSR-CorrectionPoints. SBP only supports gridded arrays of correction points lists of points. -} type alias MsgSsrTileDefinition = - { bitmask : Int - , cols : Int - , cornerNwLat : Int - , cornerNwLon : Int - , rows : Int - , spacingLat : Int - , spacingLon : Int - , tileID : Int - , tileSetID : Int + { stub : Array Int } {-| The system start-up message is sent once on system start-up. It notifies the host or @@ -2963,6 +3027,26 @@ type alias OdoInputType = { flags : Int } +{-| A full set of STEC information will likely span multiple SBP messages, since SBP message +a limited to 255 bytes. The header is used to tie multiple SBP messages into a sequence. +-} +type alias STECHeader = + { iodAtmo : Int + , numMsgs : Int + , seqNum : Int + , tileID : Int + , tileSetID : Int + , time : GpsTimeSEC + , updateInterval : Int + } + +{-| STEC polynomial for the given satellite. -} +type alias STECSatElement = + { stecCoeff : Array Int + , stecQualityIndicator : Int + , svID : SvID + } + -- decoders and encoders acqSvProfileToString : AcqSvProfile -> String @@ -3178,6 +3262,9 @@ msgFrontEndGainToString r = Jenc.encode 0 (encodeMsgFrontEndGain r) msgFwdToString : MsgFwd -> String msgFwdToString r = Jenc.encode 0 (encodeMsgFwd r) +msgGPSLeapSecondToString : MsgGPSLeapSecond -> String +msgGPSLeapSecondToString r = Jenc.encode 0 (encodeMsgGPSLeapSecond r) + msgGPSTimeToString : MsgGPSTime -> String msgGPSTimeToString r = Jenc.encode 0 (encodeMsgGPSTime r) @@ -3220,6 +3307,9 @@ msgInsUpdatesToString r = Jenc.encode 0 (encodeMsgInsUpdates r) msgIonoToString : MsgIono -> String msgIonoToString r = Jenc.encode 0 (encodeMsgIono r) +msgItrfToString : MsgItrf -> String +msgItrfToString r = Jenc.encode 0 (encodeMsgItrf r) + msgLinuxCPUStateToString : MsgLinuxCPUState -> String msgLinuxCPUStateToString r = Jenc.encode 0 (encodeMsgLinuxCPUState r) @@ -3394,12 +3484,42 @@ msgSpecanToString r = Jenc.encode 0 (encodeMsgSpecan r) msgSsrCodeBiasesToString : MsgSsrCodeBiases -> String msgSsrCodeBiasesToString r = Jenc.encode 0 (encodeMsgSsrCodeBiases r) +msgSsrCodePhaseBiasesBoundsToString : MsgSsrCodePhaseBiasesBounds -> String +msgSsrCodePhaseBiasesBoundsToString r = Jenc.encode 0 (encodeMsgSsrCodePhaseBiasesBounds r) + +msgSsrFlagHighLevelToString : MsgSsrFlagHighLevel -> String +msgSsrFlagHighLevelToString r = Jenc.encode 0 (encodeMsgSsrFlagHighLevel r) + +msgSsrFlagIonoGridPointSatLosToString : MsgSsrFlagIonoGridPointSatLos -> String +msgSsrFlagIonoGridPointSatLosToString r = Jenc.encode 0 (encodeMsgSsrFlagIonoGridPointSatLos r) + +msgSsrFlagIonoGridPointsToString : MsgSsrFlagIonoGridPoints -> String +msgSsrFlagIonoGridPointsToString r = Jenc.encode 0 (encodeMsgSsrFlagIonoGridPoints r) + +msgSsrFlagIonoTileSatLosToString : MsgSsrFlagIonoTileSatLos -> String +msgSsrFlagIonoTileSatLosToString r = Jenc.encode 0 (encodeMsgSsrFlagIonoTileSatLos r) + +msgSsrFlagSatellitesToString : MsgSsrFlagSatellites -> String +msgSsrFlagSatellitesToString r = Jenc.encode 0 (encodeMsgSsrFlagSatellites r) + +msgSsrFlagTropoGridPointsToString : MsgSsrFlagTropoGridPoints -> String +msgSsrFlagTropoGridPointsToString r = Jenc.encode 0 (encodeMsgSsrFlagTropoGridPoints r) + msgSsrGriddedCorrectionToString : MsgSsrGriddedCorrection -> String msgSsrGriddedCorrectionToString r = Jenc.encode 0 (encodeMsgSsrGriddedCorrection r) +msgSsrGriddedCorrectionBoundsToString : MsgSsrGriddedCorrectionBounds -> String +msgSsrGriddedCorrectionBoundsToString r = Jenc.encode 0 (encodeMsgSsrGriddedCorrectionBounds r) + msgSsrOrbitClockToString : MsgSsrOrbitClock -> String msgSsrOrbitClockToString r = Jenc.encode 0 (encodeMsgSsrOrbitClock r) +msgSsrOrbitClockBoundsToString : MsgSsrOrbitClockBounds -> String +msgSsrOrbitClockBoundsToString r = Jenc.encode 0 (encodeMsgSsrOrbitClockBounds r) + +msgSsrOrbitClockBoundsDegradationToString : MsgSsrOrbitClockBoundsDegradation -> String +msgSsrOrbitClockBoundsDegradationToString r = Jenc.encode 0 (encodeMsgSsrOrbitClockBoundsDegradation r) + msgSsrPhaseBiasesToString : MsgSsrPhaseBiases -> String msgSsrPhaseBiasesToString r = Jenc.encode 0 (encodeMsgSsrPhaseBiases r) @@ -4668,6 +4788,17 @@ encodeMsgFwd x = , ("source", Jenc.int x.source) ] +msgGPSLeapSecond : Jdec.Decoder MsgGPSLeapSecond +msgGPSLeapSecond = + Jpipe.decode MsgGPSLeapSecond + |> Jpipe.required "stub" (Jdec.array Jdec.int) + +encodeMsgGPSLeapSecond : MsgGPSLeapSecond -> Jenc.Value +encodeMsgGPSLeapSecond x = + Jenc.object + [ ("stub", makeArrayEncoder Jenc.int x.stub) + ] + msgGPSTime : Jdec.Decoder MsgGPSTime msgGPSTime = Jpipe.decode MsgGPSTime @@ -4951,6 +5082,17 @@ encodeMsgIono x = , ("t_nmct", encodeGpsTimeSEC x.tNmct) ] +msgItrf : Jdec.Decoder MsgItrf +msgItrf = + Jpipe.decode MsgItrf + |> Jpipe.required "stub" (Jdec.array Jdec.int) + +encodeMsgItrf : MsgItrf -> Jenc.Value +encodeMsgItrf x = + Jenc.object + [ ("stub", makeArrayEncoder Jenc.int x.stub) + ] + msgLinuxCPUState : Jdec.Decoder MsgLinuxCPUState msgLinuxCPUState = Jpipe.decode MsgLinuxCPUState @@ -6074,6 +6216,83 @@ encodeCodeBiasesContent x = , ("value", Jenc.int x.value) ] +msgSsrCodePhaseBiasesBounds : Jdec.Decoder MsgSsrCodePhaseBiasesBounds +msgSsrCodePhaseBiasesBounds = + Jpipe.decode MsgSsrCodePhaseBiasesBounds + |> Jpipe.required "stub" (Jdec.array Jdec.int) + +encodeMsgSsrCodePhaseBiasesBounds : MsgSsrCodePhaseBiasesBounds -> Jenc.Value +encodeMsgSsrCodePhaseBiasesBounds x = + Jenc.object + [ ("stub", makeArrayEncoder Jenc.int x.stub) + ] + +msgSsrFlagHighLevel : Jdec.Decoder MsgSsrFlagHighLevel +msgSsrFlagHighLevel = + Jpipe.decode MsgSsrFlagHighLevel + |> Jpipe.required "stub" (Jdec.array Jdec.int) + +encodeMsgSsrFlagHighLevel : MsgSsrFlagHighLevel -> Jenc.Value +encodeMsgSsrFlagHighLevel x = + Jenc.object + [ ("stub", makeArrayEncoder Jenc.int x.stub) + ] + +msgSsrFlagIonoGridPointSatLos : Jdec.Decoder MsgSsrFlagIonoGridPointSatLos +msgSsrFlagIonoGridPointSatLos = + Jpipe.decode MsgSsrFlagIonoGridPointSatLos + |> Jpipe.required "stub" (Jdec.array Jdec.int) + +encodeMsgSsrFlagIonoGridPointSatLos : MsgSsrFlagIonoGridPointSatLos -> Jenc.Value +encodeMsgSsrFlagIonoGridPointSatLos x = + Jenc.object + [ ("stub", makeArrayEncoder Jenc.int x.stub) + ] + +msgSsrFlagIonoGridPoints : Jdec.Decoder MsgSsrFlagIonoGridPoints +msgSsrFlagIonoGridPoints = + Jpipe.decode MsgSsrFlagIonoGridPoints + |> Jpipe.required "stub" (Jdec.array Jdec.int) + +encodeMsgSsrFlagIonoGridPoints : MsgSsrFlagIonoGridPoints -> Jenc.Value +encodeMsgSsrFlagIonoGridPoints x = + Jenc.object + [ ("stub", makeArrayEncoder Jenc.int x.stub) + ] + +msgSsrFlagIonoTileSatLos : Jdec.Decoder MsgSsrFlagIonoTileSatLos +msgSsrFlagIonoTileSatLos = + Jpipe.decode MsgSsrFlagIonoTileSatLos + |> Jpipe.required "stub" (Jdec.array Jdec.int) + +encodeMsgSsrFlagIonoTileSatLos : MsgSsrFlagIonoTileSatLos -> Jenc.Value +encodeMsgSsrFlagIonoTileSatLos x = + Jenc.object + [ ("stub", makeArrayEncoder Jenc.int x.stub) + ] + +msgSsrFlagSatellites : Jdec.Decoder MsgSsrFlagSatellites +msgSsrFlagSatellites = + Jpipe.decode MsgSsrFlagSatellites + |> Jpipe.required "stub" (Jdec.array Jdec.int) + +encodeMsgSsrFlagSatellites : MsgSsrFlagSatellites -> Jenc.Value +encodeMsgSsrFlagSatellites x = + Jenc.object + [ ("stub", makeArrayEncoder Jenc.int x.stub) + ] + +msgSsrFlagTropoGridPoints : Jdec.Decoder MsgSsrFlagTropoGridPoints +msgSsrFlagTropoGridPoints = + Jpipe.decode MsgSsrFlagTropoGridPoints + |> Jpipe.required "stub" (Jdec.array Jdec.int) + +encodeMsgSsrFlagTropoGridPoints : MsgSsrFlagTropoGridPoints -> Jenc.Value +encodeMsgSsrFlagTropoGridPoints x = + Jenc.object + [ ("stub", makeArrayEncoder Jenc.int x.stub) + ] + msgSsrGriddedCorrection : Jdec.Decoder MsgSsrGriddedCorrection msgSsrGriddedCorrection = Jpipe.decode MsgSsrGriddedCorrection @@ -6116,6 +6335,17 @@ encodeGriddedCorrectionHeader x = , ("update_interval", Jenc.int x.updateInterval) ] +msgSsrGriddedCorrectionBounds : Jdec.Decoder MsgSsrGriddedCorrectionBounds +msgSsrGriddedCorrectionBounds = + Jpipe.decode MsgSsrGriddedCorrectionBounds + |> Jpipe.required "stub" (Jdec.array Jdec.int) + +encodeMsgSsrGriddedCorrectionBounds : MsgSsrGriddedCorrectionBounds -> Jenc.Value +encodeMsgSsrGriddedCorrectionBounds x = + Jenc.object + [ ("stub", makeArrayEncoder Jenc.int x.stub) + ] + msgSsrOrbitClock : Jdec.Decoder MsgSsrOrbitClock msgSsrOrbitClock = Jpipe.decode MsgSsrOrbitClock @@ -6153,6 +6383,28 @@ encodeMsgSsrOrbitClock x = , ("update_interval", Jenc.int x.updateInterval) ] +msgSsrOrbitClockBounds : Jdec.Decoder MsgSsrOrbitClockBounds +msgSsrOrbitClockBounds = + Jpipe.decode MsgSsrOrbitClockBounds + |> Jpipe.required "stub" (Jdec.array Jdec.int) + +encodeMsgSsrOrbitClockBounds : MsgSsrOrbitClockBounds -> Jenc.Value +encodeMsgSsrOrbitClockBounds x = + Jenc.object + [ ("stub", makeArrayEncoder Jenc.int x.stub) + ] + +msgSsrOrbitClockBoundsDegradation : Jdec.Decoder MsgSsrOrbitClockBoundsDegradation +msgSsrOrbitClockBoundsDegradation = + Jpipe.decode MsgSsrOrbitClockBoundsDegradation + |> Jpipe.required "stub" (Jdec.array Jdec.int) + +encodeMsgSsrOrbitClockBoundsDegradation : MsgSsrOrbitClockBoundsDegradation -> Jenc.Value +encodeMsgSsrOrbitClockBoundsDegradation x = + Jenc.object + [ ("stub", makeArrayEncoder Jenc.int x.stub) + ] + msgSsrPhaseBiases : Jdec.Decoder MsgSsrPhaseBiases msgSsrPhaseBiases = Jpipe.decode MsgSsrPhaseBiases @@ -6232,79 +6484,23 @@ encodeSatelliteAPC x = msgSsrStecCorrection : Jdec.Decoder MsgSsrStecCorrection msgSsrStecCorrection = Jpipe.decode MsgSsrStecCorrection - |> Jpipe.required "header" stecHeader - |> Jpipe.required "stec_sat_list" (Jdec.array stecSatElement) + |> Jpipe.required "stub" (Jdec.array Jdec.int) encodeMsgSsrStecCorrection : MsgSsrStecCorrection -> Jenc.Value encodeMsgSsrStecCorrection x = Jenc.object - [ ("header", encodeSTECHeader x.header) - , ("stec_sat_list", makeArrayEncoder encodeSTECSatElement x.stecSatList) - ] - -stecHeader : Jdec.Decoder STECHeader -stecHeader = - Jpipe.decode STECHeader - |> Jpipe.required "iod_atmo" Jdec.int - |> Jpipe.required "num_msgs" Jdec.int - |> Jpipe.required "seq_num" Jdec.int - |> Jpipe.required "tile_id" Jdec.int - |> Jpipe.required "tile_set_id" Jdec.int - |> Jpipe.required "time" gpsTimeSEC - |> Jpipe.required "update_interval" Jdec.int - -encodeSTECHeader : STECHeader -> Jenc.Value -encodeSTECHeader x = - Jenc.object - [ ("iod_atmo", Jenc.int x.iodAtmo) - , ("num_msgs", Jenc.int x.numMsgs) - , ("seq_num", Jenc.int x.seqNum) - , ("tile_id", Jenc.int x.tileID) - , ("tile_set_id", Jenc.int x.tileSetID) - , ("time", encodeGpsTimeSEC x.time) - , ("update_interval", Jenc.int x.updateInterval) - ] - -stecSatElement : Jdec.Decoder STECSatElement -stecSatElement = - Jpipe.decode STECSatElement - |> Jpipe.required "stec_coeff" (Jdec.array Jdec.int) - |> Jpipe.required "stec_quality_indicator" Jdec.int - |> Jpipe.required "sv_id" svID - -encodeSTECSatElement : STECSatElement -> Jenc.Value -encodeSTECSatElement x = - Jenc.object - [ ("stec_coeff", makeArrayEncoder Jenc.int x.stecCoeff) - , ("stec_quality_indicator", Jenc.int x.stecQualityIndicator) - , ("sv_id", encodeSvID x.svID) + [ ("stub", makeArrayEncoder Jenc.int x.stub) ] msgSsrTileDefinition : Jdec.Decoder MsgSsrTileDefinition msgSsrTileDefinition = Jpipe.decode MsgSsrTileDefinition - |> Jpipe.required "bitmask" Jdec.int - |> Jpipe.required "cols" Jdec.int - |> Jpipe.required "corner_nw_lat" Jdec.int - |> Jpipe.required "corner_nw_lon" Jdec.int - |> Jpipe.required "rows" Jdec.int - |> Jpipe.required "spacing_lat" Jdec.int - |> Jpipe.required "spacing_lon" Jdec.int - |> Jpipe.required "tile_id" Jdec.int - |> Jpipe.required "tile_set_id" Jdec.int + |> Jpipe.required "stub" (Jdec.array Jdec.int) encodeMsgSsrTileDefinition : MsgSsrTileDefinition -> Jenc.Value encodeMsgSsrTileDefinition x = Jenc.object - [ ("bitmask", Jenc.int x.bitmask) - , ("cols", Jenc.int x.cols) - , ("corner_nw_lat", Jenc.int x.cornerNwLat) - , ("corner_nw_lon", Jenc.int x.cornerNwLon) - , ("rows", Jenc.int x.rows) - , ("spacing_lat", Jenc.int x.spacingLat) - , ("spacing_lon", Jenc.int x.spacingLon) - , ("tile_id", Jenc.int x.tileID) - , ("tile_set_id", Jenc.int x.tileSetID) + [ ("stub", makeArrayEncoder Jenc.int x.stub) ] msgStartup : Jdec.Decoder MsgStartup @@ -6967,6 +7163,44 @@ encodeOdoInputType x = [ ("flags", Jenc.int x.flags) ] +stecHeader : Jdec.Decoder STECHeader +stecHeader = + Jpipe.decode STECHeader + |> Jpipe.required "iod_atmo" Jdec.int + |> Jpipe.required "num_msgs" Jdec.int + |> Jpipe.required "seq_num" Jdec.int + |> Jpipe.required "tile_id" Jdec.int + |> Jpipe.required "tile_set_id" Jdec.int + |> Jpipe.required "time" gpsTimeSEC + |> Jpipe.required "update_interval" Jdec.int + +encodeSTECHeader : STECHeader -> Jenc.Value +encodeSTECHeader x = + Jenc.object + [ ("iod_atmo", Jenc.int x.iodAtmo) + , ("num_msgs", Jenc.int x.numMsgs) + , ("seq_num", Jenc.int x.seqNum) + , ("tile_id", Jenc.int x.tileID) + , ("tile_set_id", Jenc.int x.tileSetID) + , ("time", encodeGpsTimeSEC x.time) + , ("update_interval", Jenc.int x.updateInterval) + ] + +stecSatElement : Jdec.Decoder STECSatElement +stecSatElement = + Jpipe.decode STECSatElement + |> Jpipe.required "stec_coeff" (Jdec.array Jdec.int) + |> Jpipe.required "stec_quality_indicator" Jdec.int + |> Jpipe.required "sv_id" svID + +encodeSTECSatElement : STECSatElement -> Jenc.Value +encodeSTECSatElement x = + Jenc.object + [ ("stec_coeff", makeArrayEncoder Jenc.int x.stecCoeff) + , ("stec_quality_indicator", Jenc.int x.stecQualityIndicator) + , ("sv_id", encodeSvID x.svID) + ] + --- encoder helpers makeArrayEncoder : (a -> Jenc.Value) -> Array a -> Jenc.Value diff --git a/sbpjson/javascript/SbpJson.js b/sbpjson/javascript/SbpJson.js index 0fc5d1a2a3..b52b224d69 100644 --- a/sbpjson/javascript/SbpJson.js +++ b/sbpjson/javascript/SbpJson.js @@ -69,6 +69,7 @@ // const msgFlashReadResp = Convert.toMsgFlashReadResp(json); // const msgFrontEndGain = Convert.toMsgFrontEndGain(json); // const msgFwd = Convert.toMsgFwd(json); +// const msgGPSLeapSecond = Convert.toMsgGPSLeapSecond(json); // const msgGPSTime = Convert.toMsgGPSTime(json); // const msgGPSTimeGnss = Convert.toMsgGPSTimeGnss(json); // const msgGloBiases = Convert.toMsgGloBiases(json); @@ -83,6 +84,7 @@ // const msgInsStatus = Convert.toMsgInsStatus(json); // const msgInsUpdates = Convert.toMsgInsUpdates(json); // const msgIono = Convert.toMsgIono(json); +// const msgItrf = Convert.toMsgItrf(json); // const msgLinuxCPUState = Convert.toMsgLinuxCPUState(json); // const msgLinuxMemState = Convert.toMsgLinuxMemState(json); // const msgLinuxProcessFdCount = Convert.toMsgLinuxProcessFdCount(json); @@ -136,8 +138,18 @@ // const msgSolnMeta = Convert.toMsgSolnMeta(json); // const msgSpecan = Convert.toMsgSpecan(json); // const msgSsrCodeBiases = Convert.toMsgSsrCodeBiases(json); +// const msgSsrCodePhaseBiasesBounds = Convert.toMsgSsrCodePhaseBiasesBounds(json); +// const msgSsrFlagHighLevel = Convert.toMsgSsrFlagHighLevel(json); +// const msgSsrFlagIonoGridPointSatLos = Convert.toMsgSsrFlagIonoGridPointSatLos(json); +// const msgSsrFlagIonoGridPoints = Convert.toMsgSsrFlagIonoGridPoints(json); +// const msgSsrFlagIonoTileSatLos = Convert.toMsgSsrFlagIonoTileSatLos(json); +// const msgSsrFlagSatellites = Convert.toMsgSsrFlagSatellites(json); +// const msgSsrFlagTropoGridPoints = Convert.toMsgSsrFlagTropoGridPoints(json); // const msgSsrGriddedCorrection = Convert.toMsgSsrGriddedCorrection(json); +// const msgSsrGriddedCorrectionBounds = Convert.toMsgSsrGriddedCorrectionBounds(json); // const msgSsrOrbitClock = Convert.toMsgSsrOrbitClock(json); +// const msgSsrOrbitClockBounds = Convert.toMsgSsrOrbitClockBounds(json); +// const msgSsrOrbitClockBoundsDegradation = Convert.toMsgSsrOrbitClockBoundsDegradation(json); // const msgSsrPhaseBiases = Convert.toMsgSsrPhaseBiases(json); // const msgSsrSatelliteApc = Convert.toMsgSsrSatelliteApc(json); // const msgSsrStecCorrection = Convert.toMsgSsrStecCorrection(json); @@ -732,6 +744,14 @@ function msgFwdToJson(value) { return JSON.stringify(uncast(value, r("MsgFwd")), null, 2); } +function toMsgGPSLeapSecond(json) { + return cast(JSON.parse(json), r("MsgGPSLeapSecond")); +} + +function msgGPSLeapSecondToJson(value) { + return JSON.stringify(uncast(value, r("MsgGPSLeapSecond")), null, 2); +} + function toMsgGPSTime(json) { return cast(JSON.parse(json), r("MsgGPSTime")); } @@ -844,6 +864,14 @@ function msgIonoToJson(value) { return JSON.stringify(uncast(value, r("MsgIono")), null, 2); } +function toMsgItrf(json) { + return cast(JSON.parse(json), r("MsgItrf")); +} + +function msgItrfToJson(value) { + return JSON.stringify(uncast(value, r("MsgItrf")), null, 2); +} + function toMsgLinuxCPUState(json) { return cast(JSON.parse(json), r("MsgLinuxCPUState")); } @@ -1268,6 +1296,62 @@ function msgSsrCodeBiasesToJson(value) { return JSON.stringify(uncast(value, r("MsgSsrCodeBiases")), null, 2); } +function toMsgSsrCodePhaseBiasesBounds(json) { + return cast(JSON.parse(json), r("MsgSsrCodePhaseBiasesBounds")); +} + +function msgSsrCodePhaseBiasesBoundsToJson(value) { + return JSON.stringify(uncast(value, r("MsgSsrCodePhaseBiasesBounds")), null, 2); +} + +function toMsgSsrFlagHighLevel(json) { + return cast(JSON.parse(json), r("MsgSsrFlagHighLevel")); +} + +function msgSsrFlagHighLevelToJson(value) { + return JSON.stringify(uncast(value, r("MsgSsrFlagHighLevel")), null, 2); +} + +function toMsgSsrFlagIonoGridPointSatLos(json) { + return cast(JSON.parse(json), r("MsgSsrFlagIonoGridPointSatLos")); +} + +function msgSsrFlagIonoGridPointSatLosToJson(value) { + return JSON.stringify(uncast(value, r("MsgSsrFlagIonoGridPointSatLos")), null, 2); +} + +function toMsgSsrFlagIonoGridPoints(json) { + return cast(JSON.parse(json), r("MsgSsrFlagIonoGridPoints")); +} + +function msgSsrFlagIonoGridPointsToJson(value) { + return JSON.stringify(uncast(value, r("MsgSsrFlagIonoGridPoints")), null, 2); +} + +function toMsgSsrFlagIonoTileSatLos(json) { + return cast(JSON.parse(json), r("MsgSsrFlagIonoTileSatLos")); +} + +function msgSsrFlagIonoTileSatLosToJson(value) { + return JSON.stringify(uncast(value, r("MsgSsrFlagIonoTileSatLos")), null, 2); +} + +function toMsgSsrFlagSatellites(json) { + return cast(JSON.parse(json), r("MsgSsrFlagSatellites")); +} + +function msgSsrFlagSatellitesToJson(value) { + return JSON.stringify(uncast(value, r("MsgSsrFlagSatellites")), null, 2); +} + +function toMsgSsrFlagTropoGridPoints(json) { + return cast(JSON.parse(json), r("MsgSsrFlagTropoGridPoints")); +} + +function msgSsrFlagTropoGridPointsToJson(value) { + return JSON.stringify(uncast(value, r("MsgSsrFlagTropoGridPoints")), null, 2); +} + function toMsgSsrGriddedCorrection(json) { return cast(JSON.parse(json), r("MsgSsrGriddedCorrection")); } @@ -1276,6 +1360,14 @@ function msgSsrGriddedCorrectionToJson(value) { return JSON.stringify(uncast(value, r("MsgSsrGriddedCorrection")), null, 2); } +function toMsgSsrGriddedCorrectionBounds(json) { + return cast(JSON.parse(json), r("MsgSsrGriddedCorrectionBounds")); +} + +function msgSsrGriddedCorrectionBoundsToJson(value) { + return JSON.stringify(uncast(value, r("MsgSsrGriddedCorrectionBounds")), null, 2); +} + function toMsgSsrOrbitClock(json) { return cast(JSON.parse(json), r("MsgSsrOrbitClock")); } @@ -1284,6 +1376,22 @@ function msgSsrOrbitClockToJson(value) { return JSON.stringify(uncast(value, r("MsgSsrOrbitClock")), null, 2); } +function toMsgSsrOrbitClockBounds(json) { + return cast(JSON.parse(json), r("MsgSsrOrbitClockBounds")); +} + +function msgSsrOrbitClockBoundsToJson(value) { + return JSON.stringify(uncast(value, r("MsgSsrOrbitClockBounds")), null, 2); +} + +function toMsgSsrOrbitClockBoundsDegradation(json) { + return cast(JSON.parse(json), r("MsgSsrOrbitClockBoundsDegradation")); +} + +function msgSsrOrbitClockBoundsDegradationToJson(value) { + return JSON.stringify(uncast(value, r("MsgSsrOrbitClockBoundsDegradation")), null, 2); +} + function toMsgSsrPhaseBiases(json) { return cast(JSON.parse(json), r("MsgSsrPhaseBiases")); } @@ -2240,6 +2348,9 @@ const typeMap = { { json: "protocol", js: "protocol", typ: 0 }, { json: "source", js: "source", typ: 0 }, ], "any"), + "MsgGPSLeapSecond": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), "MsgGPSTime": o([ { json: "flags", js: "flags", typ: 0 }, { json: "ns_residual", js: "ns_residual", typ: 0 }, @@ -2344,6 +2455,9 @@ const typeMap = { { json: "b3", js: "b3", typ: 3.14 }, { json: "t_nmct", js: "t_nmct", typ: r("GpsTimeSEC") }, ], "any"), + "MsgItrf": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), "MsgLinuxCPUState": o([ { json: "cmdline", js: "cmdline", typ: "" }, { json: "flags", js: "flags", typ: 0 }, @@ -2758,6 +2872,27 @@ const typeMap = { { json: "code", js: "code", typ: 0 }, { json: "value", js: "value", typ: 0 }, ], "any"), + "MsgSsrCodePhaseBiasesBounds": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), + "MsgSsrFlagHighLevel": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), + "MsgSsrFlagIonoGridPointSatLos": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), + "MsgSsrFlagIonoGridPoints": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), + "MsgSsrFlagIonoTileSatLos": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), + "MsgSsrFlagSatellites": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), + "MsgSsrFlagTropoGridPoints": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), "MsgSsrGriddedCorrection": o([ { json: "header", js: "header", typ: r("GriddedCorrectionHeader") }, { json: "index", js: "index", typ: 0 }, @@ -2774,6 +2909,9 @@ const typeMap = { { json: "tropo_quality_indicator", js: "tropo_quality_indicator", typ: 0 }, { json: "update_interval", js: "update_interval", typ: 0 }, ], "any"), + "MsgSsrGriddedCorrectionBounds": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), "MsgSsrOrbitClock": o([ { json: "along", js: "along", typ: 0 }, { json: "c0", js: "c0", typ: 0 }, @@ -2790,6 +2928,12 @@ const typeMap = { { json: "time", js: "time", typ: r("GpsTimeSEC") }, { json: "update_interval", js: "update_interval", typ: 0 }, ], "any"), + "MsgSsrOrbitClockBounds": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), + "MsgSsrOrbitClockBoundsDegradation": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), "MsgSsrPhaseBiases": o([ { json: "biases", js: "biases", typ: a(r("PhaseBiasesContent")) }, { json: "dispersive_bias", js: "dispersive_bias", typ: 0 }, @@ -2819,33 +2963,10 @@ const typeMap = { { json: "svn", js: "svn", typ: 0 }, ], "any"), "MsgSsrStecCorrection": o([ - { json: "header", js: "header", typ: r("STECHeader") }, - { json: "stec_sat_list", js: "stec_sat_list", typ: a(r("STECSatElement")) }, - ], "any"), - "STECHeader": o([ - { json: "iod_atmo", js: "iod_atmo", typ: 0 }, - { json: "num_msgs", js: "num_msgs", typ: 0 }, - { json: "seq_num", js: "seq_num", typ: 0 }, - { json: "tile_id", js: "tile_id", typ: 0 }, - { json: "tile_set_id", js: "tile_set_id", typ: 0 }, - { json: "time", js: "time", typ: r("GpsTimeSEC") }, - { json: "update_interval", js: "update_interval", typ: 0 }, - ], "any"), - "STECSatElement": o([ - { json: "stec_coeff", js: "stec_coeff", typ: a(0) }, - { json: "stec_quality_indicator", js: "stec_quality_indicator", typ: 0 }, - { json: "sv_id", js: "sv_id", typ: r("SvID") }, + { json: "stub", js: "stub", typ: a(0) }, ], "any"), "MsgSsrTileDefinition": o([ - { json: "bitmask", js: "bitmask", typ: 0 }, - { json: "cols", js: "cols", typ: 0 }, - { json: "corner_nw_lat", js: "corner_nw_lat", typ: 0 }, - { json: "corner_nw_lon", js: "corner_nw_lon", typ: 0 }, - { json: "rows", js: "rows", typ: 0 }, - { json: "spacing_lat", js: "spacing_lat", typ: 0 }, - { json: "spacing_lon", js: "spacing_lon", typ: 0 }, - { json: "tile_id", js: "tile_id", typ: 0 }, - { json: "tile_set_id", js: "tile_set_id", typ: 0 }, + { json: "stub", js: "stub", typ: a(0) }, ], "any"), "MsgStartup": o([ { json: "cause", js: "cause", typ: 0 }, @@ -3092,6 +3213,20 @@ const typeMap = { "OdoInputType": o([ { json: "flags", js: "flags", typ: 0 }, ], "any"), + "STECHeader": o([ + { json: "iod_atmo", js: "iod_atmo", typ: 0 }, + { json: "num_msgs", js: "num_msgs", typ: 0 }, + { json: "seq_num", js: "seq_num", typ: 0 }, + { json: "tile_id", js: "tile_id", typ: 0 }, + { json: "tile_set_id", js: "tile_set_id", typ: 0 }, + { json: "time", js: "time", typ: r("GpsTimeSEC") }, + { json: "update_interval", js: "update_interval", typ: 0 }, + ], "any"), + "STECSatElement": o([ + { json: "stec_coeff", js: "stec_coeff", typ: a(0) }, + { json: "stec_quality_indicator", js: "stec_quality_indicator", typ: 0 }, + { json: "sv_id", js: "sv_id", typ: r("SvID") }, + ], "any"), }; module.exports = { @@ -3229,6 +3364,8 @@ module.exports = { "toMsgFrontEndGain": toMsgFrontEndGain, "msgFwdToJson": msgFwdToJson, "toMsgFwd": toMsgFwd, + "msgGPSLeapSecondToJson": msgGPSLeapSecondToJson, + "toMsgGPSLeapSecond": toMsgGPSLeapSecond, "msgGPSTimeToJson": msgGPSTimeToJson, "toMsgGPSTime": toMsgGPSTime, "msgGPSTimeGnssToJson": msgGPSTimeGnssToJson, @@ -3257,6 +3394,8 @@ module.exports = { "toMsgInsUpdates": toMsgInsUpdates, "msgIonoToJson": msgIonoToJson, "toMsgIono": toMsgIono, + "msgItrfToJson": msgItrfToJson, + "toMsgItrf": toMsgItrf, "msgLinuxCPUStateToJson": msgLinuxCPUStateToJson, "toMsgLinuxCPUState": toMsgLinuxCPUState, "msgLinuxMemStateToJson": msgLinuxMemStateToJson, @@ -3363,10 +3502,30 @@ module.exports = { "toMsgSpecan": toMsgSpecan, "msgSsrCodeBiasesToJson": msgSsrCodeBiasesToJson, "toMsgSsrCodeBiases": toMsgSsrCodeBiases, + "msgSsrCodePhaseBiasesBoundsToJson": msgSsrCodePhaseBiasesBoundsToJson, + "toMsgSsrCodePhaseBiasesBounds": toMsgSsrCodePhaseBiasesBounds, + "msgSsrFlagHighLevelToJson": msgSsrFlagHighLevelToJson, + "toMsgSsrFlagHighLevel": toMsgSsrFlagHighLevel, + "msgSsrFlagIonoGridPointSatLosToJson": msgSsrFlagIonoGridPointSatLosToJson, + "toMsgSsrFlagIonoGridPointSatLos": toMsgSsrFlagIonoGridPointSatLos, + "msgSsrFlagIonoGridPointsToJson": msgSsrFlagIonoGridPointsToJson, + "toMsgSsrFlagIonoGridPoints": toMsgSsrFlagIonoGridPoints, + "msgSsrFlagIonoTileSatLosToJson": msgSsrFlagIonoTileSatLosToJson, + "toMsgSsrFlagIonoTileSatLos": toMsgSsrFlagIonoTileSatLos, + "msgSsrFlagSatellitesToJson": msgSsrFlagSatellitesToJson, + "toMsgSsrFlagSatellites": toMsgSsrFlagSatellites, + "msgSsrFlagTropoGridPointsToJson": msgSsrFlagTropoGridPointsToJson, + "toMsgSsrFlagTropoGridPoints": toMsgSsrFlagTropoGridPoints, "msgSsrGriddedCorrectionToJson": msgSsrGriddedCorrectionToJson, "toMsgSsrGriddedCorrection": toMsgSsrGriddedCorrection, + "msgSsrGriddedCorrectionBoundsToJson": msgSsrGriddedCorrectionBoundsToJson, + "toMsgSsrGriddedCorrectionBounds": toMsgSsrGriddedCorrectionBounds, "msgSsrOrbitClockToJson": msgSsrOrbitClockToJson, "toMsgSsrOrbitClock": toMsgSsrOrbitClock, + "msgSsrOrbitClockBoundsToJson": msgSsrOrbitClockBoundsToJson, + "toMsgSsrOrbitClockBounds": toMsgSsrOrbitClockBounds, + "msgSsrOrbitClockBoundsDegradationToJson": msgSsrOrbitClockBoundsDegradationToJson, + "toMsgSsrOrbitClockBoundsDegradation": toMsgSsrOrbitClockBoundsDegradation, "msgSsrPhaseBiasesToJson": msgSsrPhaseBiasesToJson, "toMsgSsrPhaseBiases": toMsgSsrPhaseBiases, "msgSsrSatelliteApcToJson": msgSsrSatelliteApcToJson, diff --git a/sbpjson/typescript/SbpJson.ts b/sbpjson/typescript/SbpJson.ts index 588ed93b9d..0271ee93c6 100644 --- a/sbpjson/typescript/SbpJson.ts +++ b/sbpjson/typescript/SbpJson.ts @@ -1,6 +1,6 @@ // To parse this data: // -// import { Convert, AcqSvProfile, AlmanacCommonContent, CarrierPhase, CodeBiasesContent, Doppler, EphemerisCommonContent, EstimatedHorizontalErrorEllipse, GNSSInputType, GnssCapb, GnssSignal, GpsTime, GpsTimeSEC, GridElement, GridElementNoStd, GriddedCorrectionHeader, IMUInputType, Latency, MeasurementState, MsgAcqResult, MsgAcqSvProfile, MsgAgeCorrections, MsgAlmanacGPS, MsgAlmanacGlo, MsgAngularRate, MsgBasePosECEF, MsgBasePosLLH, MsgBaselineECEF, MsgBaselineHeading, MsgBaselineNED, MsgBootloaderHandshakeResp, MsgBootloaderJumpToApp, MsgCellModemStatus, MsgCommandOutput, MsgCommandReq, MsgCommandResp, MsgCsacTelemetry, MsgCsacTelemetryLabels, MsgDeviceMonitor, MsgDgnssStatus, MsgDops, MsgEphemerisBds, MsgEphemerisGPS, MsgEphemerisGal, MsgEphemerisGlo, MsgEphemerisQzss, MsgEphemerisSbas, MsgEXTEvent, MsgFileioConfigReq, MsgFileioConfigResp, MsgFileioReadDirReq, MsgFileioReadDirResp, MsgFileioReadReq, MsgFileioReadResp, MsgFileioRemove, MsgFileioWriteReq, MsgFileioWriteResp, MsgFlashDone, MsgFlashErase, MsgFlashProgram, MsgFlashReadReq, MsgFlashReadResp, MsgFrontEndGain, MsgFwd, MsgGPSTime, MsgGPSTimeGnss, MsgGloBiases, MsgGnssCapb, MsgGnssTimeOffset, MsgGroupDelay, MsgGroupMeta, MsgHeartbeat, MsgIarState, MsgImuAux, MsgImuRaw, MsgInsStatus, MsgInsUpdates, MsgIono, MsgLinuxCPUState, MsgLinuxMemState, MsgLinuxProcessFdCount, MsgLinuxProcessFdSummary, MsgLinuxProcessSocketCounts, MsgLinuxProcessSocketQueues, MsgLinuxSocketUsage, MsgLinuxSysState, MsgLog, MsgM25FlashWriteStatus, MsgMagRaw, MsgMaskSatellite, MsgMeasurementState, MsgNapDeviceDnaResp, MsgNdbEvent, MsgNetworkBandwidthUsage, MsgNetworkStateResp, MsgObs, MsgOdometry, MsgOrientEuler, MsgOrientQuat, MsgOsr, MsgPosECEF, MsgPosECEFCov, MsgPosECEFCovGnss, MsgPosECEFGnss, MsgPosLLH, MsgPosLLHAcc, MsgPosLLHCov, MsgPosLLHCovGnss, MsgPosLLHGnss, MsgPpsTime, MsgProtectionLevel, MsgReset, MsgResetFilters, MsgSbasRaw, MsgSensorAidEvent, MsgSettingsReadByIndexReq, MsgSettingsReadByIndexResp, MsgSettingsReadReq, MsgSettingsReadResp, MsgSettingsRegister, MsgSettingsRegisterResp, MsgSettingsWrite, MsgSettingsWriteResp, MsgSolnMeta, MsgSpecan, MsgSsrCodeBiases, MsgSsrGriddedCorrection, MsgSsrOrbitClock, MsgSsrPhaseBiases, MsgSsrSatelliteApc, MsgSsrStecCorrection, MsgSsrTileDefinition, MsgStartup, MsgStatusJournal, MsgStatusReport, MsgStmFlashLockSector, MsgStmFlashUnlockSector, MsgStmUniqueIDResp, MsgSvAzEl, MsgThreadState, MsgTrackingIq, MsgTrackingState, MsgUARTState, MsgUserData, MsgUTCTime, MsgUTCTimeGnss, MsgVelBody, MsgVelCog, MsgVelECEF, MsgVelECEFCov, MsgVelECEFCovGnss, MsgVelECEFGnss, MsgVelNED, MsgVelNEDCov, MsgVelNEDCovGnss, MsgVelNEDGnss, MsgWheeltick, NetworkUsage, ObservationHeader, OdoInputType, PackedObsContent, PackedOsrContent, Period, PhaseBiasesContent, STECHeader, STECResidual, STECResidualNoStd, STECSatElement, SatelliteAPC, SolutionInputType, StatusJournalItem, SubSystemReport, SvAzEl, SvID, TrackingChannelCorrelation, TrackingChannelState, TroposphericDelayCorrection, TroposphericDelayCorrectionNoStd, UARTChannel } from "./file"; +// import { Convert, AcqSvProfile, AlmanacCommonContent, CarrierPhase, CodeBiasesContent, Doppler, EphemerisCommonContent, EstimatedHorizontalErrorEllipse, GNSSInputType, GnssCapb, GnssSignal, GpsTime, GpsTimeSEC, GridElement, GridElementNoStd, GriddedCorrectionHeader, IMUInputType, Latency, MeasurementState, MsgAcqResult, MsgAcqSvProfile, MsgAgeCorrections, MsgAlmanacGPS, MsgAlmanacGlo, MsgAngularRate, MsgBasePosECEF, MsgBasePosLLH, MsgBaselineECEF, MsgBaselineHeading, MsgBaselineNED, MsgBootloaderHandshakeResp, MsgBootloaderJumpToApp, MsgCellModemStatus, MsgCommandOutput, MsgCommandReq, MsgCommandResp, MsgCsacTelemetry, MsgCsacTelemetryLabels, MsgDeviceMonitor, MsgDgnssStatus, MsgDops, MsgEphemerisBds, MsgEphemerisGPS, MsgEphemerisGal, MsgEphemerisGlo, MsgEphemerisQzss, MsgEphemerisSbas, MsgEXTEvent, MsgFileioConfigReq, MsgFileioConfigResp, MsgFileioReadDirReq, MsgFileioReadDirResp, MsgFileioReadReq, MsgFileioReadResp, MsgFileioRemove, MsgFileioWriteReq, MsgFileioWriteResp, MsgFlashDone, MsgFlashErase, MsgFlashProgram, MsgFlashReadReq, MsgFlashReadResp, MsgFrontEndGain, MsgFwd, MsgGPSLeapSecond, MsgGPSTime, MsgGPSTimeGnss, MsgGloBiases, MsgGnssCapb, MsgGnssTimeOffset, MsgGroupDelay, MsgGroupMeta, MsgHeartbeat, MsgIarState, MsgImuAux, MsgImuRaw, MsgInsStatus, MsgInsUpdates, MsgIono, MsgItrf, MsgLinuxCPUState, MsgLinuxMemState, MsgLinuxProcessFdCount, MsgLinuxProcessFdSummary, MsgLinuxProcessSocketCounts, MsgLinuxProcessSocketQueues, MsgLinuxSocketUsage, MsgLinuxSysState, MsgLog, MsgM25FlashWriteStatus, MsgMagRaw, MsgMaskSatellite, MsgMeasurementState, MsgNapDeviceDnaResp, MsgNdbEvent, MsgNetworkBandwidthUsage, MsgNetworkStateResp, MsgObs, MsgOdometry, MsgOrientEuler, MsgOrientQuat, MsgOsr, MsgPosECEF, MsgPosECEFCov, MsgPosECEFCovGnss, MsgPosECEFGnss, MsgPosLLH, MsgPosLLHAcc, MsgPosLLHCov, MsgPosLLHCovGnss, MsgPosLLHGnss, MsgPpsTime, MsgProtectionLevel, MsgReset, MsgResetFilters, MsgSbasRaw, MsgSensorAidEvent, MsgSettingsReadByIndexReq, MsgSettingsReadByIndexResp, MsgSettingsReadReq, MsgSettingsReadResp, MsgSettingsRegister, MsgSettingsRegisterResp, MsgSettingsWrite, MsgSettingsWriteResp, MsgSolnMeta, MsgSpecan, MsgSsrCodeBiases, MsgSsrCodePhaseBiasesBounds, MsgSsrFlagHighLevel, MsgSsrFlagIonoGridPointSatLos, MsgSsrFlagIonoGridPoints, MsgSsrFlagIonoTileSatLos, MsgSsrFlagSatellites, MsgSsrFlagTropoGridPoints, MsgSsrGriddedCorrection, MsgSsrGriddedCorrectionBounds, MsgSsrOrbitClock, MsgSsrOrbitClockBounds, MsgSsrOrbitClockBoundsDegradation, MsgSsrPhaseBiases, MsgSsrSatelliteApc, MsgSsrStecCorrection, MsgSsrTileDefinition, MsgStartup, MsgStatusJournal, MsgStatusReport, MsgStmFlashLockSector, MsgStmFlashUnlockSector, MsgStmUniqueIDResp, MsgSvAzEl, MsgThreadState, MsgTrackingIq, MsgTrackingState, MsgUARTState, MsgUserData, MsgUTCTime, MsgUTCTimeGnss, MsgVelBody, MsgVelCog, MsgVelECEF, MsgVelECEFCov, MsgVelECEFCovGnss, MsgVelECEFGnss, MsgVelNED, MsgVelNEDCov, MsgVelNEDCovGnss, MsgVelNEDGnss, MsgWheeltick, NetworkUsage, ObservationHeader, OdoInputType, PackedObsContent, PackedOsrContent, Period, PhaseBiasesContent, STECHeader, STECResidual, STECResidualNoStd, STECSatElement, SatelliteAPC, SolutionInputType, StatusJournalItem, SubSystemReport, SvAzEl, SvID, TrackingChannelCorrelation, TrackingChannelState, TroposphericDelayCorrection, TroposphericDelayCorrectionNoStd, UARTChannel } from "./file"; // // const acqSvProfile = Convert.toAcqSvProfile(json); // const almanacCommonContent = Convert.toAlmanacCommonContent(json); @@ -69,6 +69,7 @@ // const msgFlashReadResp = Convert.toMsgFlashReadResp(json); // const msgFrontEndGain = Convert.toMsgFrontEndGain(json); // const msgFwd = Convert.toMsgFwd(json); +// const msgGPSLeapSecond = Convert.toMsgGPSLeapSecond(json); // const msgGPSTime = Convert.toMsgGPSTime(json); // const msgGPSTimeGnss = Convert.toMsgGPSTimeGnss(json); // const msgGloBiases = Convert.toMsgGloBiases(json); @@ -83,6 +84,7 @@ // const msgInsStatus = Convert.toMsgInsStatus(json); // const msgInsUpdates = Convert.toMsgInsUpdates(json); // const msgIono = Convert.toMsgIono(json); +// const msgItrf = Convert.toMsgItrf(json); // const msgLinuxCPUState = Convert.toMsgLinuxCPUState(json); // const msgLinuxMemState = Convert.toMsgLinuxMemState(json); // const msgLinuxProcessFdCount = Convert.toMsgLinuxProcessFdCount(json); @@ -136,8 +138,18 @@ // const msgSolnMeta = Convert.toMsgSolnMeta(json); // const msgSpecan = Convert.toMsgSpecan(json); // const msgSsrCodeBiases = Convert.toMsgSsrCodeBiases(json); +// const msgSsrCodePhaseBiasesBounds = Convert.toMsgSsrCodePhaseBiasesBounds(json); +// const msgSsrFlagHighLevel = Convert.toMsgSsrFlagHighLevel(json); +// const msgSsrFlagIonoGridPointSatLos = Convert.toMsgSsrFlagIonoGridPointSatLos(json); +// const msgSsrFlagIonoGridPoints = Convert.toMsgSsrFlagIonoGridPoints(json); +// const msgSsrFlagIonoTileSatLos = Convert.toMsgSsrFlagIonoTileSatLos(json); +// const msgSsrFlagSatellites = Convert.toMsgSsrFlagSatellites(json); +// const msgSsrFlagTropoGridPoints = Convert.toMsgSsrFlagTropoGridPoints(json); // const msgSsrGriddedCorrection = Convert.toMsgSsrGriddedCorrection(json); +// const msgSsrGriddedCorrectionBounds = Convert.toMsgSsrGriddedCorrectionBounds(json); // const msgSsrOrbitClock = Convert.toMsgSsrOrbitClock(json); +// const msgSsrOrbitClockBounds = Convert.toMsgSsrOrbitClockBounds(json); +// const msgSsrOrbitClockBoundsDegradation = Convert.toMsgSsrOrbitClockBoundsDegradation(json); // const msgSsrPhaseBiases = Convert.toMsgSsrPhaseBiases(json); // const msgSsrSatelliteApc = Convert.toMsgSsrSatelliteApc(json); // const msgSsrStecCorrection = Convert.toMsgSsrStecCorrection(json); @@ -948,6 +960,14 @@ export interface MsgFwd { source: number; } +/** + * Emulates the GPS CNAV message, reserving bytes for future broadcast of the drift model + * parameters. + */ +export interface MsgGPSLeapSecond { + stub: number[]; +} + /** * This message reports the GPS time, representing the time since the GPS epoch began on * midnight January 6, 1980 UTC. GPS time counts the weeks and seconds of the week. The @@ -1152,6 +1172,10 @@ export interface MsgIono { t_nmct: GpsTimeSEC; } +export interface MsgItrf { + stub: number[]; +} + /** * This message indicates the process state of the top 10 heaviest consumers of CPU on the * system, including a timestamp. @@ -1957,6 +1981,34 @@ export interface CodeBiasesContent { value: number; } +export interface MsgSsrCodePhaseBiasesBounds { + stub: number[]; +} + +export interface MsgSsrFlagHighLevel { + stub: number[]; +} + +export interface MsgSsrFlagIonoGridPointSatLos { + stub: number[]; +} + +export interface MsgSsrFlagIonoGridPoints { + stub: number[]; +} + +export interface MsgSsrFlagIonoTileSatLos { + stub: number[]; +} + +export interface MsgSsrFlagSatellites { + stub: number[]; +} + +export interface MsgSsrFlagTropoGridPoints { + stub: number[]; +} + /** * STEC residuals are per space vehicle, troposphere is not., * , @@ -1984,6 +2036,10 @@ export interface GriddedCorrectionHeader { update_interval: number; } +export interface MsgSsrGriddedCorrectionBounds { + stub: number[]; +} + /** * The precise orbit and clock correction message is to be applied as a delta correction to * broadcast ephemeris and is an equivalent to the 1060 /1066 RTCM message types. @@ -2005,6 +2061,14 @@ export interface MsgSsrOrbitClock { update_interval: number; } +export interface MsgSsrOrbitClockBounds { + stub: number[]; +} + +export interface MsgSsrOrbitClockBoundsDegradation { + stub: number[]; +} + /** * The precise phase biases message contains the biases to be added to the carrier phase of * the corresponding signal to get corrected carrier phase measurement, as well as the @@ -2050,39 +2114,8 @@ export interface SatelliteAPC { svn: number; } -/** - * The Slant Total Electron Content per space vehicle, given as polynomial approximation for - * a given tile. This should be combined with the MSG_SSR_GRIDDED_CORRECTION message to get - * the state space representation of the atmospheric delay., - * , - * It is typically equivalent to the QZSS CLAS Sub Type 8 messages. - */ export interface MsgSsrStecCorrection { - header: STECHeader; - stec_sat_list: STECSatElement[]; -} - -/** - * A full set of STEC information will likely span multiple SBP messages, since SBP message - * a limited to 255 bytes. The header is used to tie multiple SBP messages into a sequence. - */ -export interface STECHeader { - iod_atmo: number; - num_msgs: number; - seq_num: number; - tile_id: number; - tile_set_id: number; - time: GpsTimeSEC; - update_interval: number; -} - -/** - * STEC polynomial for the given satellite. - */ -export interface STECSatElement { - stec_coeff: number[]; - stec_quality_indicator: number; - sv_id: SvID; + stub: number[]; } /** @@ -2094,15 +2127,7 @@ export interface STECSatElement { * lists of points. */ export interface MsgSsrTileDefinition { - bitmask: number; - cols: number; - corner_nw_lat: number; - corner_nw_lon: number; - rows: number; - spacing_lat: number; - spacing_lon: number; - tile_id: number; - tile_set_id: number; + stub: number[]; } /** @@ -2565,6 +2590,29 @@ export interface OdoInputType { flags: number; } +/** + * A full set of STEC information will likely span multiple SBP messages, since SBP message + * a limited to 255 bytes. The header is used to tie multiple SBP messages into a sequence. + */ +export interface STECHeader { + iod_atmo: number; + num_msgs: number; + seq_num: number; + tile_id: number; + tile_set_id: number; + time: GpsTimeSEC; + update_interval: number; +} + +/** + * STEC polynomial for the given satellite. + */ +export interface STECSatElement { + stec_coeff: number[]; + stec_quality_indicator: number; + sv_id: SvID; +} + // Converts JSON strings to/from your types // and asserts the results of JSON.parse at runtime export class Convert { @@ -3104,6 +3152,14 @@ export class Convert { return JSON.stringify(uncast(value, r("MsgFwd")), null, 2); } + public static toMsgGPSLeapSecond(json: string): MsgGPSLeapSecond { + return cast(JSON.parse(json), r("MsgGPSLeapSecond")); + } + + public static msgGPSLeapSecondToJson(value: MsgGPSLeapSecond): string { + return JSON.stringify(uncast(value, r("MsgGPSLeapSecond")), null, 2); + } + public static toMsgGPSTime(json: string): MsgGPSTime { return cast(JSON.parse(json), r("MsgGPSTime")); } @@ -3216,6 +3272,14 @@ export class Convert { return JSON.stringify(uncast(value, r("MsgIono")), null, 2); } + public static toMsgItrf(json: string): MsgItrf { + return cast(JSON.parse(json), r("MsgItrf")); + } + + public static msgItrfToJson(value: MsgItrf): string { + return JSON.stringify(uncast(value, r("MsgItrf")), null, 2); + } + public static toMsgLinuxCPUState(json: string): MsgLinuxCPUState { return cast(JSON.parse(json), r("MsgLinuxCPUState")); } @@ -3640,6 +3704,62 @@ export class Convert { return JSON.stringify(uncast(value, r("MsgSsrCodeBiases")), null, 2); } + public static toMsgSsrCodePhaseBiasesBounds(json: string): MsgSsrCodePhaseBiasesBounds { + return cast(JSON.parse(json), r("MsgSsrCodePhaseBiasesBounds")); + } + + public static msgSsrCodePhaseBiasesBoundsToJson(value: MsgSsrCodePhaseBiasesBounds): string { + return JSON.stringify(uncast(value, r("MsgSsrCodePhaseBiasesBounds")), null, 2); + } + + public static toMsgSsrFlagHighLevel(json: string): MsgSsrFlagHighLevel { + return cast(JSON.parse(json), r("MsgSsrFlagHighLevel")); + } + + public static msgSsrFlagHighLevelToJson(value: MsgSsrFlagHighLevel): string { + return JSON.stringify(uncast(value, r("MsgSsrFlagHighLevel")), null, 2); + } + + public static toMsgSsrFlagIonoGridPointSatLos(json: string): MsgSsrFlagIonoGridPointSatLos { + return cast(JSON.parse(json), r("MsgSsrFlagIonoGridPointSatLos")); + } + + public static msgSsrFlagIonoGridPointSatLosToJson(value: MsgSsrFlagIonoGridPointSatLos): string { + return JSON.stringify(uncast(value, r("MsgSsrFlagIonoGridPointSatLos")), null, 2); + } + + public static toMsgSsrFlagIonoGridPoints(json: string): MsgSsrFlagIonoGridPoints { + return cast(JSON.parse(json), r("MsgSsrFlagIonoGridPoints")); + } + + public static msgSsrFlagIonoGridPointsToJson(value: MsgSsrFlagIonoGridPoints): string { + return JSON.stringify(uncast(value, r("MsgSsrFlagIonoGridPoints")), null, 2); + } + + public static toMsgSsrFlagIonoTileSatLos(json: string): MsgSsrFlagIonoTileSatLos { + return cast(JSON.parse(json), r("MsgSsrFlagIonoTileSatLos")); + } + + public static msgSsrFlagIonoTileSatLosToJson(value: MsgSsrFlagIonoTileSatLos): string { + return JSON.stringify(uncast(value, r("MsgSsrFlagIonoTileSatLos")), null, 2); + } + + public static toMsgSsrFlagSatellites(json: string): MsgSsrFlagSatellites { + return cast(JSON.parse(json), r("MsgSsrFlagSatellites")); + } + + public static msgSsrFlagSatellitesToJson(value: MsgSsrFlagSatellites): string { + return JSON.stringify(uncast(value, r("MsgSsrFlagSatellites")), null, 2); + } + + public static toMsgSsrFlagTropoGridPoints(json: string): MsgSsrFlagTropoGridPoints { + return cast(JSON.parse(json), r("MsgSsrFlagTropoGridPoints")); + } + + public static msgSsrFlagTropoGridPointsToJson(value: MsgSsrFlagTropoGridPoints): string { + return JSON.stringify(uncast(value, r("MsgSsrFlagTropoGridPoints")), null, 2); + } + public static toMsgSsrGriddedCorrection(json: string): MsgSsrGriddedCorrection { return cast(JSON.parse(json), r("MsgSsrGriddedCorrection")); } @@ -3648,6 +3768,14 @@ export class Convert { return JSON.stringify(uncast(value, r("MsgSsrGriddedCorrection")), null, 2); } + public static toMsgSsrGriddedCorrectionBounds(json: string): MsgSsrGriddedCorrectionBounds { + return cast(JSON.parse(json), r("MsgSsrGriddedCorrectionBounds")); + } + + public static msgSsrGriddedCorrectionBoundsToJson(value: MsgSsrGriddedCorrectionBounds): string { + return JSON.stringify(uncast(value, r("MsgSsrGriddedCorrectionBounds")), null, 2); + } + public static toMsgSsrOrbitClock(json: string): MsgSsrOrbitClock { return cast(JSON.parse(json), r("MsgSsrOrbitClock")); } @@ -3656,6 +3784,22 @@ export class Convert { return JSON.stringify(uncast(value, r("MsgSsrOrbitClock")), null, 2); } + public static toMsgSsrOrbitClockBounds(json: string): MsgSsrOrbitClockBounds { + return cast(JSON.parse(json), r("MsgSsrOrbitClockBounds")); + } + + public static msgSsrOrbitClockBoundsToJson(value: MsgSsrOrbitClockBounds): string { + return JSON.stringify(uncast(value, r("MsgSsrOrbitClockBounds")), null, 2); + } + + public static toMsgSsrOrbitClockBoundsDegradation(json: string): MsgSsrOrbitClockBoundsDegradation { + return cast(JSON.parse(json), r("MsgSsrOrbitClockBoundsDegradation")); + } + + public static msgSsrOrbitClockBoundsDegradationToJson(value: MsgSsrOrbitClockBoundsDegradation): string { + return JSON.stringify(uncast(value, r("MsgSsrOrbitClockBoundsDegradation")), null, 2); + } + public static toMsgSsrPhaseBiases(json: string): MsgSsrPhaseBiases { return cast(JSON.parse(json), r("MsgSsrPhaseBiases")); } @@ -4613,6 +4757,9 @@ const typeMap: any = { { json: "protocol", js: "protocol", typ: 0 }, { json: "source", js: "source", typ: 0 }, ], "any"), + "MsgGPSLeapSecond": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), "MsgGPSTime": o([ { json: "flags", js: "flags", typ: 0 }, { json: "ns_residual", js: "ns_residual", typ: 0 }, @@ -4717,6 +4864,9 @@ const typeMap: any = { { json: "b3", js: "b3", typ: 3.14 }, { json: "t_nmct", js: "t_nmct", typ: r("GpsTimeSEC") }, ], "any"), + "MsgItrf": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), "MsgLinuxCPUState": o([ { json: "cmdline", js: "cmdline", typ: "" }, { json: "flags", js: "flags", typ: 0 }, @@ -5131,6 +5281,27 @@ const typeMap: any = { { json: "code", js: "code", typ: 0 }, { json: "value", js: "value", typ: 0 }, ], "any"), + "MsgSsrCodePhaseBiasesBounds": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), + "MsgSsrFlagHighLevel": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), + "MsgSsrFlagIonoGridPointSatLos": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), + "MsgSsrFlagIonoGridPoints": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), + "MsgSsrFlagIonoTileSatLos": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), + "MsgSsrFlagSatellites": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), + "MsgSsrFlagTropoGridPoints": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), "MsgSsrGriddedCorrection": o([ { json: "header", js: "header", typ: r("GriddedCorrectionHeader") }, { json: "index", js: "index", typ: 0 }, @@ -5147,6 +5318,9 @@ const typeMap: any = { { json: "tropo_quality_indicator", js: "tropo_quality_indicator", typ: 0 }, { json: "update_interval", js: "update_interval", typ: 0 }, ], "any"), + "MsgSsrGriddedCorrectionBounds": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), "MsgSsrOrbitClock": o([ { json: "along", js: "along", typ: 0 }, { json: "c0", js: "c0", typ: 0 }, @@ -5163,6 +5337,12 @@ const typeMap: any = { { json: "time", js: "time", typ: r("GpsTimeSEC") }, { json: "update_interval", js: "update_interval", typ: 0 }, ], "any"), + "MsgSsrOrbitClockBounds": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), + "MsgSsrOrbitClockBoundsDegradation": o([ + { json: "stub", js: "stub", typ: a(0) }, + ], "any"), "MsgSsrPhaseBiases": o([ { json: "biases", js: "biases", typ: a(r("PhaseBiasesContent")) }, { json: "dispersive_bias", js: "dispersive_bias", typ: 0 }, @@ -5192,33 +5372,10 @@ const typeMap: any = { { json: "svn", js: "svn", typ: 0 }, ], "any"), "MsgSsrStecCorrection": o([ - { json: "header", js: "header", typ: r("STECHeader") }, - { json: "stec_sat_list", js: "stec_sat_list", typ: a(r("STECSatElement")) }, - ], "any"), - "STECHeader": o([ - { json: "iod_atmo", js: "iod_atmo", typ: 0 }, - { json: "num_msgs", js: "num_msgs", typ: 0 }, - { json: "seq_num", js: "seq_num", typ: 0 }, - { json: "tile_id", js: "tile_id", typ: 0 }, - { json: "tile_set_id", js: "tile_set_id", typ: 0 }, - { json: "time", js: "time", typ: r("GpsTimeSEC") }, - { json: "update_interval", js: "update_interval", typ: 0 }, - ], "any"), - "STECSatElement": o([ - { json: "stec_coeff", js: "stec_coeff", typ: a(0) }, - { json: "stec_quality_indicator", js: "stec_quality_indicator", typ: 0 }, - { json: "sv_id", js: "sv_id", typ: r("SvID") }, + { json: "stub", js: "stub", typ: a(0) }, ], "any"), "MsgSsrTileDefinition": o([ - { json: "bitmask", js: "bitmask", typ: 0 }, - { json: "cols", js: "cols", typ: 0 }, - { json: "corner_nw_lat", js: "corner_nw_lat", typ: 0 }, - { json: "corner_nw_lon", js: "corner_nw_lon", typ: 0 }, - { json: "rows", js: "rows", typ: 0 }, - { json: "spacing_lat", js: "spacing_lat", typ: 0 }, - { json: "spacing_lon", js: "spacing_lon", typ: 0 }, - { json: "tile_id", js: "tile_id", typ: 0 }, - { json: "tile_set_id", js: "tile_set_id", typ: 0 }, + { json: "stub", js: "stub", typ: a(0) }, ], "any"), "MsgStartup": o([ { json: "cause", js: "cause", typ: 0 }, @@ -5465,4 +5622,18 @@ const typeMap: any = { "OdoInputType": o([ { json: "flags", js: "flags", typ: 0 }, ], "any"), + "STECHeader": o([ + { json: "iod_atmo", js: "iod_atmo", typ: 0 }, + { json: "num_msgs", js: "num_msgs", typ: 0 }, + { json: "seq_num", js: "seq_num", typ: 0 }, + { json: "tile_id", js: "tile_id", typ: 0 }, + { json: "tile_set_id", js: "tile_set_id", typ: 0 }, + { json: "time", js: "time", typ: r("GpsTimeSEC") }, + { json: "update_interval", js: "update_interval", typ: 0 }, + ], "any"), + "STECSatElement": o([ + { json: "stec_coeff", js: "stec_coeff", typ: a(0) }, + { json: "stec_quality_indicator", js: "stec_quality_indicator", typ: 0 }, + { json: "sv_id", js: "sv_id", typ: r("SvID") }, + ], "any"), }; diff --git a/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml new file mode 100644 index 0000000000..f72c38f4d4 --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml @@ -0,0 +1,23 @@ +description: Unit tests for swiftnav.sbp.integrity MsgSsrFlagHighLevel +generated_on: 2022-04-21 # manually generated +package: sbp.integrity +tests: + + - msg: + fields: + stub: [180,0,0,0,3,0,104,1,0,0,6,0,10,20,0,30,0,40,1,2,3,0,0,0,0,0,0,4,5,6,7] + c_decoded_fields: + n_stub: 31 + module: sbp.integrity + name: MsgSsrFlagHighLevel + msg_type: '3001' + raw_json: '{"stub": [180,0,0,0,3,0,104,1,0,0,6,0,10,20,0,30,0,40,1,2,3,0,0,0,0,0,0,4,5,6,7], + "preamble": 85, "msg_type": 3001, "sender": 66, "length": 31, "payload": "tAAAAAMAaAEAAAYAChQAHgAoAQIDAAAAAAAABAUGBw==", "crc": 17254}' + raw_packet: VbkLQgAftAAAAAMAaAEAAAYAChQAHgAoAQIDAAAAAAAABAUGB2ZD + sbp: + preamble: '0x55' + msg_type: '0x0BB9' + sender: '0x0042' + length: 31 + payload: tAAAAAMAaAEAAAYAChQAHgAoAQIDAAAAAAAABAUGBw== + crc: '0x4366' diff --git a/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPointSatLos.yaml b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPointSatLos.yaml new file mode 100644 index 0000000000..a909b4ebb8 --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPointSatLos.yaml @@ -0,0 +1,23 @@ +description: Unit tests for swiftnav.sbp.integrity MsgSsrFlagIonoGridPointSatLos +generated_on: 2022-04-22 # manually generated +package: sbp.integrity +tests: + + - msg: + fields: + stub: [180,0,0,0,3,0,1,2,3,4,0,5,0,6,30,0,2,10,11,15,14] + c_decoded_fields: + n_stub: 21 + module: sbp.integrity + name: MsgSsrFlagIonoGridPointSatLos + msg_type: '3025' + raw_json: '{"stub": [180,0,0,0,3,0,1,2,3,4,0,5,0,6,30,0,2,10,11,15,14], "preamble": 85, "msg_type": 3025, "sender": 66, "length": 21, + "payload": "tAAAAAMAAQIDBAAFAAYeAAIKCw8O", "crc": 37986}' + raw_packet: VdELQgAVtAAAAAMAAQIDBAAFAAYeAAIKCw8OYpQ= + sbp: + preamble: '0x55' + msg_type: '0x0BD1' + sender: '0x0042' + length: 21 + payload: tAAAAAMAAQIDBAAFAAYeAAIKCw8O + crc: '0x9462' diff --git a/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPoints.yaml b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPoints.yaml new file mode 100644 index 0000000000..0edc51ee50 --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPoints.yaml @@ -0,0 +1,23 @@ +description: Unit tests for swiftnav.sbp.integrity MsgSsrFlagIonoGridPoints +generated_on: 2022-04-22 # manually generated +package: sbp.integrity +tests: + + - msg: + fields: + stub: [180,0,0,0,3,0,1,2,3,4,0,5,0,6,3,10,0,11,0,12,0] + c_decoded_fields: + n_stub: 21 + module: sbp.integrity + name: MsgSsrFlagIonoGridPoints + msg_type: '3015' + raw_json: '{"stub": [180,0,0,0,3,0,1,2,3,4,0,5,0,6,3,10,0,11,0,12,0], "preamble": 85, "msg_type": 3015, + "sender": 66, "length": 21, "payload": "tAAAAAMAAQIDBAAFAAYDCgALAAwA", "crc": 1845}' + raw_packet: VccLQgAVtAAAAAMAAQIDBAAFAAYDCgALAAwANQc= + sbp: + preamble: '0x55' + msg_type: '0x0BC7' + sender: '0x0042' + length: 21 + payload: tAAAAAMAAQIDBAAFAAYDCgALAAwA + crc: '0x0735' diff --git a/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoTileSatLos.yaml b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoTileSatLos.yaml new file mode 100644 index 0000000000..faacd14279 --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoTileSatLos.yaml @@ -0,0 +1,23 @@ +description: Unit tests for swiftnav.sbp.integrity MsgSsrFlagIonoTileSatLos +generated_on: 2022-04-22 # manually generated +package: sbp.integrity +tests: + + - msg: + fields: + stub: [180,0,0,0,3,0,1,2,3,4,0,5,0,6,2,10,11,15,14] + c_decoded_fields: + n_stub: 19 + module: sbp.integrity + name: MsgSsrFlagIonoTileSatLos + msg_type: '3021' + raw_json: '{"stub": [180,0,0,0,3,0,1,2,3,4,0,5,0,6,2,10,11,15,14], "preamble": 85, "msg_type": 3021, "sender": 66, "length": 19, + "payload": "tAAAAAMAAQIDBAAFAAYCCgsPDg==", "crc": 60399}' + raw_packet: Vc0LQgATtAAAAAMAAQIDBAAFAAYCCgsPDu/r + sbp: + preamble: '0x55' + msg_type: '0x0BCD' + sender: '0x0042' + length: 19 + payload: tAAAAAMAAQIDBAAFAAYCCgsPDg== + crc: '0xEBEF' diff --git a/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagSatellites.yaml b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagSatellites.yaml new file mode 100644 index 0000000000..435812c468 --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagSatellites.yaml @@ -0,0 +1,23 @@ +description: Unit tests for swiftnav.sbp.integrity MsgSsrFlagSatellites +generated_on: 2022-04-22 # manually generated +package: sbp.integrity +tests: + + - msg: + fields: + stub: [180,0,0,0,3,0,1,2,3,4,5,3,10,11,12] + c_decoded_fields: + n_stub: 15 + module: sbp.integrity + name: MsgSsrFlagSatellites + msg_type: '3005' + raw_json: '{"stub": [180,0,0,0,3,0,1,2,3,4,5,3,10,11,12], "preamble": 85, "msg_type": 3005, "sender": 66, "length": 15, + "payload": "tAAAAAMAAQIDBAUDCgsM", "crc": 42350}' + raw_packet: Vb0LQgAPtAAAAAMAAQIDBAUDCgsMbqU= + sbp: + preamble: '0x55' + msg_type: '0x0BBD' + sender: '0x0042' + length: 15 + payload: tAAAAAMAAQIDBAUDCgsM + crc: '0xA56E' diff --git a/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagTropoGridPoints.yaml b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagTropoGridPoints.yaml new file mode 100644 index 0000000000..07db470a9c --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagTropoGridPoints.yaml @@ -0,0 +1,23 @@ +description: Unit tests for swiftnav.sbp.integrity MsgSsrFlagTropoGridPoints +generated_on: 2022-04-22 # manually generated +package: sbp.integrity +tests: + + - msg: + fields: + stub: [180,0,0,0,3,0,1,2,3,4,0,5,0,6,3,10,0,11,0,12,0] + c_decoded_fields: + n_stub: 21 + module: sbp.integrity + name: MsgSsrFlagTropoGridPoints + msg_type: '3011' + raw_json: '{"stub": [180,0,0,0,3,0,1,2,3,4,0,5,0,6,3,10,0,11,0,12,0], "preamble": 85, "msg_type": 3011, + "sender": 66, "length": 21, "payload": "tAAAAAMAAQIDBAAFAAYDCgALAAwA", "crc": 38643}' + raw_packet: VcMLQgAVtAAAAAMAAQIDBAAFAAYDCgALAAwA85Y= + sbp: + preamble: '0x55' + msg_type: '0x0BC3' + sender: '0x0042' + length: 21 + payload: tAAAAAMAAQIDBAAFAAYDCgALAAwA + crc: '0x96F3' diff --git a/spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSLeapSecond.yaml b/spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSLeapSecond.yaml new file mode 100644 index 0000000000..7a6cd85ba6 --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSLeapSecond.yaml @@ -0,0 +1,24 @@ +description: Unit tests for swiftnav.sbp.navigation MsgGPSLeapSecond +generated_on: 2022-05-11 # manually generated +package: sbp.navigation +tests: + + - msg: + fields: + stub: [1, 0, 2, 0, 3, 4, 5, 0, 6, 0, 7, 0, 8, 9] + c_decoded_fields: + n_stub: 14 + module: sbp.navigation + name: MsgGPSLeapSecond + msg_type: '570' + raw_json: '{"stub": [1, 0, 2, 0, 3, 4, 5, 0, 6, 0, 7, 0, 8, 9], + "preamble": 85, "msg_type": 570, "sender": 66, "length": 14, + "payload": "AQACAAMEBQAGAAcACAk=", "crc": 59442}' + raw_packet: VToCQgAOAQACAAMEBQAGAAcACAky6A== + sbp: + preamble: '0x55' + msg_type: '0x023A' + sender: '0x0042' + length: 14 + payload: AQACAAMEBQAGAAcACAk= + crc: '0xE832' diff --git a/spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml b/spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml new file mode 100644 index 0000000000..a39ddff760 --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml @@ -0,0 +1,34 @@ +description: Unit tests for swiftnav.sbp.navigation MsgItrf +generated_on: 2022-05-11 # manually generated +package: sbp.navigation +tests: + + - msg: + fields: + stub: [1, 2, 102, 111, 111, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, + 98, 97, 114, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 0, + 6, 0, 7, 0, 0, 0, 8, 0, 0, 0, 9, 0, 0, 0, 10, 0, 0, + 0, 11, 0, 0, 0, 12, 0, 0, 0, 13, 0, 0, 0, 14, 0, 0, 0, + 15, 0, 0, 0, 16, 0, 0, 0, 17, 0, 0, 0, 18, 0, 0, 0, 19, + 0, 0, 0, 20, 0] + c_decoded_fields: + n_stub: 124 + module: sbp.navigation + name: MsgItrf + msg_type: '580' + raw_json: '{"stub": [1,2,102,111,111,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,98,97,114,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,5,0,6,0,7,0,0,0,8,0,0,0,9,0,0,0,10,0,0,0,11,0,0,0,12,0,0,0,13,0,0, + 0,14,0,0,0,15,0,0,0,16,0,0,0,17,0,0,0,18,0,0,0,19,0,0,0,20,0], + "preamble": 85, "msg_type": 580, "sender": 66, "length": 124, + "payload": "AQJmb28AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2JhcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBQAGAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAABAAAAARAAAAEgAAABMAAAAUAA==", + "crc": 32322}' + raw_packet: VUQCQgB8AQJmb28AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2JhcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBQAGAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAABAAAAARAAAAEgAAABMAAAAUAEJ+ + sbp: + preamble: '0x55' + msg_type: '0x0244' + sender: '0x0042' + length: 124 + payload: AQJmb28AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2JhcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBQAGAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAABAAAAARAAAAEgAAABMAAAAUAA== + crc: '0x7E42' diff --git a/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrCodePhaseBiasesBounds.yaml b/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrCodePhaseBiasesBounds.yaml new file mode 100644 index 0000000000..533ae6664e --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrCodePhaseBiasesBounds.yaml @@ -0,0 +1,23 @@ +description: Unit tests for swiftnav.sbp.ssr MsgSsrCodePhaseBiasesBounds +generated_on: 2022-04-12 # manually generated +package: sbp.ssr +tests: + + - msg: + fields: + stub: [180,0,0,0,3,0,1,2,1,14,15,1,3,0,3,39,1,39,1,1,3,39,1,39,1,1,1,39,1,39,1] + c_decoded_fields: + n_stub: 31 + module: sbp.ssr + name: MsgSsrCodePhaseBiasesBounds + msg_type: '1516' + raw_json: '{"stub": [180,0,0,0,3,0,1,2,1,14,15,1,3,0,3,39,1,39,1,1,3,39,1,39,1,1,1,39,1,39,1], "preamble": 85, + "msg_type": 1516, "sender": 66, "length": 31, "payload": "tAAAAAMAAQIBDg8BAwADJwEnAQEDJwEnAQEBJwEnAQ==", "crc": 28951}' + raw_packet: VewFQgAftAAAAAMAAQIBDg8BAwADJwEnAQEDJwEnAQEBJwEnARdx + sbp: + preamble: '0x55' + msg_type: '0x05EC' + sender: '0x0042' + length: 31 + payload: tAAAAAMAAQIBDg8BAwADJwEnAQEDJwEnAQEBJwEnAQ== + crc: '0x7117' diff --git a/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrectionBounds.yaml b/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrectionBounds.yaml new file mode 100644 index 0000000000..4fa9c7da8a --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrectionBounds.yaml @@ -0,0 +1,24 @@ +description: Unit tests for swiftnav.sbp.ssr MsgSsrGriddedCorrectionBounds +generated_on: 2022-04-19 # manually generated +package: sbp.ssr +tests: + + - msg: + fields: + stub: [180,0,0,0,3,0,1,1,10,0,15,1,0,10,0,39,232,3,244,1,100,200,150,100,2,5,10,16,0,17,18,19,20,21,6,10,22,0,23,24,25,26,27] + c_decoded_fields: + n_stub: 43 + module: sbp.ssr + name: MsgSsrGriddedCorrectionBounds + msg_type: '1534' + raw_json: '{"stub": [180,0,0,0,3,0,1,1,10,0,15,1,0,10,0,39,232,3,244,1,100,200,150,100,2,5,10,16,0,17,18,19,20,21,6,10,22,0,23,24,25,26,27], + "preamble": 85, "msg_type": 1534, "sender": 66, "length": 43, + "payload": "tAAAAAMAAQEKAA8BAAoAJ+gD9AFkyJZkAgUKEAAREhMUFQYKFgAXGBkaGw==", "crc": 37232}' + raw_packet: Vf4FQgArtAAAAAMAAQEKAA8BAAoAJ+gD9AFkyJZkAgUKEAAREhMUFQYKFgAXGBkaG3CR + sbp: + preamble: '0x55' + msg_type: '0x05FE' + sender: '0x0042' + length: 43 + payload: tAAAAAMAAQEKAA8BAAoAJ+gD9AFkyJZkAgUKEAAREhMUFQYKFgAXGBkaGw== + crc: '0x9170' diff --git a/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBounds.yaml b/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBounds.yaml new file mode 100644 index 0000000000..531f9d4a99 --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBounds.yaml @@ -0,0 +1,23 @@ +description: Unit tests for swiftnav.sbp.ssr MsgSsrOrbitClockBounds +generated_on: 2022-04-08 # manually generated +package: sbp.ssr +tests: + + - msg: + fields: + stub: [180,0,0,0,3,0,1,2,3,48,15,1,2,24,39,38,37,1,2,3,39,1,3,39,38,37,1,2,3,39,1] + c_decoded_fields: + n_stub: 31 + module: sbp.ssr + name: MsgSsrOrbitClockBounds + msg_type: '1502' + raw_json: '{"stub": [180,0,0,0,3,0,1,2,3,48,15,1,2,24,39,38,37,1,2,3,39,1,3,39,38,37,1,2,3,39,1], "preamble": 85, + "msg_type": 1502, "sender": 66, "length": 31, "payload": "tAAAAAMAAQIDMA8BAhgnJiUBAgMnAQMnJiUBAgMnAQ==", "crc": 21781}' + raw_packet: Vd4FQgAftAAAAAMAAQIDMA8BAhgnJiUBAgMnAQMnJiUBAgMnARVV + sbp: + preamble: '0x55' + msg_type: '0x05DE' + sender: '0x0042' + length: 31 + payload: tAAAAAMAAQIDMA8BAhgnJiUBAgMnAQMnJiUBAgMnAQ== + crc: '0x5515' diff --git a/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBoundsDegradation.yaml b/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBoundsDegradation.yaml new file mode 100644 index 0000000000..420f64fecd --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBoundsDegradation.yaml @@ -0,0 +1,25 @@ +description: Unit tests for swiftnav.sbp.ssr MsgSsrOrbitClockBoundsDegradation +generated_on: 2022-04-18 # manually generated +package: sbp.ssr + +tests: + + - msg: + fields: + stub: [180,0,0,0,3,0,1,2,3,48,15,1,10,0,0,0,0,0,0,0,200,199,198,197,196,195,194,193] + c_decoded_fields: + n_stub: 28 + module: sbp.ssr + name: MsgSsrOrbitClockBoundsDegradation + msg_type: '1503' + raw_json: '{"stub": [180,0,0,0,3,0,1,2,3,48,15,1,10,0,0,0,0,0,0,0,200,199,198,197,196,195,194,193], + "preamble": 85, "msg_type": 1503, "sender": 66, "length": 28, + "payload": "tAAAAAMAAQIDMA8BCgAAAAAAAADIx8bFxMPCwQ==", "crc": 30152}' + raw_packet: Vd8FQgActAAAAAMAAQIDMA8BCgAAAAAAAADIx8bFxMPCwch1 + sbp: + preamble: '0x55' + msg_type: '0x05DF' + sender: '0x0042' + length: 28 + payload: tAAAAAMAAQIDMA8BCgAAAAAAAADIx8bFxMPCwQ== + crc: '0x75C8' diff --git a/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrStecCorrection.yaml b/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrStecCorrection.yaml new file mode 100644 index 0000000000..f6f5fdcf77 --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrStecCorrection.yaml @@ -0,0 +1,23 @@ +description: Unit tests for swiftnav.sbp.ssr MsgSsrStecCorrection +generated_on: 2022-04-19 # manually generated +package: sbp.ssr +tests: + + - msg: + fields: + stub: [180,0,0,0,3,0,1,1,10,0,15,1,0,10,0,2,1,1,1,63,0,62,0,61,0,60,0,31,15,5,63,0,64,0,65,0,66,0] + c_decoded_fields: + n_stub: 38 + module: sbp.ssr + name: MsgSsrStecCorrection + msg_type: '1533' + raw_json: '{"stub": [180,0,0,0,3,0,1,1,10,0,15,1,0,10,0,2,1,1,1,63,0,62,0,61,0,60,0,31,15,5,63,0,64,0,65,0,66,0], + "preamble": 85, "msg_type": 1533, "sender": 66, "length": 38, "payload": "tAAAAAMAAQEKAA8BAAoAAgEBAT8APgA9ADwAHw8FPwBAAEEAQgA=", "crc": 12919}' + raw_packet: Vf0FQgAmtAAAAAMAAQEKAA8BAAoAAgEBAT8APgA9ADwAHw8FPwBAAEEAQgB3Mg== + sbp: + preamble: '0x55' + msg_type: '0x05FD' + sender: '0x0042' + length: 38 + payload: tAAAAAMAAQEKAA8BAAoAAgEBAT8APgA9ADwAHw8FPwBAAEEAQgA= + crc: '0x3277' diff --git a/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrTileDefinition.yaml b/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrTileDefinition.yaml new file mode 100644 index 0000000000..ef5a15493f --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrTileDefinition.yaml @@ -0,0 +1,23 @@ +description: Unit tests for swiftnav.sbp.ssr MsgSsrTileDefinition +generated_on: 2022-04-20 # manually generated +package: sbp.ssr +tests: + + - msg: + fields: + stub: [31,0,1,0,2,0,4,0,8,0,16,0,32,0,64,0,128,210,2,150,73,0,0,0,0] + c_decoded_fields: + n_stub: 25 + module: sbp.ssr + name: MsgSsrTileDefinition + msg_type: '1527' + raw_json: '{"stub": [31,0,1,0,2,0,4,0,8,0,16,0,32,0,64,0,128,210,2,150,73,0,0,0,0], "preamble": 85, + "msg_type": 1527, "sender": 66, "length": 25, "payload": "HwABAAIABAAIABAAIABAAIDSApZJAAAAAA==", "crc": 18390}' + raw_packet: VfcFQgAZHwABAAIABAAIABAAIABAAIDSApZJAAAAANZH + sbp: + preamble: '0x55' + msg_type: '0x05F7' + sender: '0x0042' + length: 25 + payload: HwABAAIABAAIABAAIABAAIDSApZJAAAAAA== + crc: '0x47D6' diff --git a/spec/yaml/swiftnav/sbp/integrity.yaml b/spec/yaml/swiftnav/sbp/integrity.yaml new file mode 100644 index 0000000000..6a1cab30c9 --- /dev/null +++ b/spec/yaml/swiftnav/sbp/integrity.yaml @@ -0,0 +1,71 @@ +# Copyright (C) 2018-2022 Swift Navigation Inc. +# Contact: https://support.swiftnav.com +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +package: swiftnav.sbp.integrity +description: Integrity flag messages +stable: False +public: False +include: + - types.yaml + - gnss.yaml +definitions: + - MSG_SSR_FLAG_HIGH_LEVEL: + id: 0x0BB9 + short_desc: High level integrity flags + public: False + fields: + - stub: + type: array + fill: u8 + + - MSG_SSR_FLAG_SATELLITES: + id: 0x0BBD + short_desc: List of satellites which are faulty, per constellation + public: False + fields: + - stub: + type: array + fill: u8 + + - MSG_SSR_FLAG_TROPO_GRID_POINTS: + id: 0x0BC3 + short_desc: List of grid points which are faulty + public: False + fields: + - stub: + type: array + fill: u8 + + - MSG_SSR_FLAG_IONO_GRID_POINTS: + id: 0x0BC7 + short_desc: List of grid points which are faulty + public: False + fields: + - stub: + type: array + fill: u8 + + - MSG_SSR_FLAG_IONO_TILE_SAT_LOS: + id: 0x0BCD + short_desc: List of all the LOS which are faulty + public: False + fields: + - stub: + type: array + fill: u8 + + - MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS: + id: 0x0BD1 + short_desc: List of all the grid points to satellite which are faulty + public: False + fields: + - stub: + type: array + fill: u8 diff --git a/spec/yaml/swiftnav/sbp/navigation.yaml b/spec/yaml/swiftnav/sbp/navigation.yaml index d06bd5458b..6033fdfeca 100644 --- a/spec/yaml/swiftnav/sbp/navigation.yaml +++ b/spec/yaml/swiftnav/sbp/navigation.yaml @@ -2427,3 +2427,24 @@ definitions: desc: Safe state POPL - 31: desc: Safe state ROPL + + - MSG_GPS_LEAP_SECOND: + id: 0x023A + short_desc: > + Leap second SBP message. + desc: > + Emulates the GPS CNAV message, reserving bytes for future broadcast of + the drift model parameters. + fields: + - stub: + type: array + fill: u8 + + - MSG_ITRF: + id: 0x0244 + short_desc: Reference Frame Transformation Parameter + public: False + fields: + - stub: + type: array + fill: u8 diff --git a/spec/yaml/swiftnav/sbp/ssr.yaml b/spec/yaml/swiftnav/sbp/ssr.yaml index db3c3df261..fe5a8837aa 100644 --- a/spec/yaml/swiftnav/sbp/ssr.yaml +++ b/spec/yaml/swiftnav/sbp/ssr.yaml @@ -359,7 +359,7 @@ definitions: Phase biases corrections for a satellite being tracked. - - MSG_SSR_STEC_CORRECTION: + - MSG_SSR_STEC_CORRECTION_DEP: id: 0x05FB short_desc: STEC correction polynomial coefficients desc: > @@ -370,6 +370,8 @@ definitions: It is typically equivalent to the QZSS CLAS Sub Type 8 messages. + replaced_by: + - MSG_SSR_STEC_CORRECTION fields: - header: type: STECHeader @@ -379,6 +381,15 @@ definitions: fill: STECSatElement desc: Array of STEC polynomial coefficients for each space vehicle. + - MSG_SSR_STEC_CORRECTION: + id: 0x05FD + short_desc: STEC correction polynomial coefficients + public: False + fields: + - stub: + type: array + fill: u8 + - MSG_SSR_GRIDDED_CORRECTION: id: 0x05FC short_desc: Gridded troposphere and STEC correction residuals @@ -402,19 +413,30 @@ definitions: fill: STECResidual desc: STEC residuals for each satellite (mean, stddev). - - MSG_SSR_TILE_DEFINITION: + - MSG_SSR_GRIDDED_CORRECTION_BOUNDS: + id: 0x05FE + short_desc: Gridded troposhere and STEC correction residuals bounds + public: False + fields: + - stub: + type: array + fill: u8 + + - MSG_SSR_TILE_DEFINITION_DEP: id: 0x05F6 short_desc: > Definition of a SSR atmospheric correction tile. desc: > Provides the correction point coordinates for the atmospheric correction - values in the MSG_SSR_STEC_CORRECTION and MSG_SSR_GRIDDED_CORRECTION + values in the MSG_SSR_STEC_CORRECTION_DEP and MSG_SSR_GRIDDED_CORRECTION messages. Based on ETSI TS 137 355 V16.1.0 (LTE Positioning Protocol) information element GNSS-SSR-CorrectionPoints. SBP only supports gridded arrays of correction points, not lists of points. + replaced_by: + - MSG_SSR_TILE_DEFINITION fields: - tile_set_id: type: u16 @@ -508,6 +530,25 @@ definitions: See GNSS-SSR-ArrayOfCorrectionPoints field bitmaskOfGrids but note the definition of the bits is inverted. + - MSG_SSR_TILE_DEFINITION: + id: 0x05F7 + short_desc: > + Definition of a SSR atmospheric correction tile. + desc: > + Provides the correction point coordinates for the atmospheric correction + values in the MSG_SSR_STEC_CORRECTION and MSG_SSR_GRIDDED_CORRECTION + messages. + + + Based on ETSI TS 137 355 V16.1.0 (LTE Positioning Protocol) information + element GNSS-SSR-CorrectionPoints. SBP only supports gridded arrays of + correction points, not lists of points. + public: False + fields: + - stub: + type: array + fill: u8 + - SatelliteAPC: short_desc: Antenna phase center correction desc: > @@ -789,7 +830,7 @@ definitions: short_desc: Deprecated public: False replaced_by: - - MSG_SSR_TILE_DEFINITION + - MSG_SSR_TILE_DEFINITION_DEP fields: - header: type: GridDefinitionHeaderDepA @@ -802,3 +843,30 @@ definitions: The spec describes the encoding scheme in detail, but essentially the index of the quadrants that contain transitions between valid and invalid (and vice versa) are encoded as u8 integers. + + - MSG_SSR_ORBIT_CLOCK_BOUNDS: + id: 0x05DE + short_desc: Stubbed version of Combined Orbit and Clock Bound + public: False + fields: + - stub: + type: array + fill: u8 + + - MSG_SSR_CODE_PHASE_BIASES_BOUNDS: + id: 0x05EC + short_desc: Stubbed version of Combined Code and Phase Biases Bounds + public: False + fields: + - stub: + type: array + fill: u8 + + - MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION: + id: 0x05DF + short_desc: Combined Orbit and Clock Bound Degradation Parameter + public: False + fields: + - stub: + type: array + fill: u8 From 24859a22e567a654f75bb4d55b285e0ec9729590 Mon Sep 17 00:00:00 2001 From: fpezzinosn Date: Fri, 13 May 2022 16:37:08 -0400 Subject: [PATCH 2/2] append staging to version conditionally --- Makefile | 11 ++++++++--- generator/sbpg/__init__.py | 1 + generator/sbpg/generator.py | 13 ++++++++++--- generator/sbpg/targets/c.py | 1 + .../sbpg/targets/resources/c/sbp_version_template.h | 3 +++ 5 files changed, 23 insertions(+), 6 deletions(-) diff --git a/Makefile b/Makefile index aca19baef8..f939c869e5 100644 --- a/Makefile +++ b/Makefile @@ -180,12 +180,17 @@ deps-quicktype-elm: verify-prereq-quicktype gen: gen-c gen-python gen-javascript gen-java gen-haskell gen-rust gen-protobuf gen-jsonschema gen-quicktype gen-quicktype: gen-quicktype-typescript gen-quicktype-elm +gen-c_args = -i $(SBP_SPEC_DIR) \ + -o $(SWIFTNAV_ROOT)/c \ + -r $(SBP_VERSION) +ifeq ($(SBP_STAGING), 1) + gen-c_args += -s +endif + gen-c: $(call announce-begin,"Generating C headers and sources") cd $(SWIFTNAV_ROOT)/generator; \ - $(SBP_GEN_BIN) -i $(SBP_SPEC_DIR) \ - -o $(SWIFTNAV_ROOT)/c \ - -r $(SBP_VERSION) \ + $(SBP_GEN_BIN) $(gen-c_args) \ --c $(call announce-begin,"Generating C tests") diff --git a/generator/sbpg/__init__.py b/generator/sbpg/__init__.py index f073f63a4d..7b9e585114 100644 --- a/generator/sbpg/__init__.py +++ b/generator/sbpg/__init__.py @@ -7,3 +7,4 @@ class ReleaseVersion: patch: str patch_pre: str full_version: str + is_staging: int diff --git a/generator/sbpg/generator.py b/generator/sbpg/generator.py index b08013fef5..b91f95ccbd 100755 --- a/generator/sbpg/generator.py +++ b/generator/sbpg/generator.py @@ -77,6 +77,10 @@ def get_args(): nargs=1, required=True, help='Release version.') + parser.add_argument('-s', + '--staging', + action="store_true", + help='Is a staging branch') parser.add_argument('-v', '--verbose', action="store_true", @@ -84,7 +88,7 @@ def get_args(): return parser -def parse_release_version(release: str) -> ReleaseVersion: +def parse_release_version(release: str, staging: bool) -> ReleaseVersion: major, minor, patch = release.split('.')[:3] major = major.lstrip('v') if '-' in patch: @@ -94,11 +98,14 @@ def parse_release_version(release: str) -> ReleaseVersion: else: patch_pre = patch full_version = "{}.{}.{}".format(major, minor, patch) + if staging: + full_version += '-staging' return ReleaseVersion(major=major, minor=minor, patch=patch, patch_pre=patch_pre, - full_version=full_version) + full_version=full_version, + is_staging=int(staging),) def main(): try: @@ -125,7 +132,7 @@ def main(): # Sort the files - we need them to be in a stable order for some test generation file_index_items = sorted(file_index.items(), key=lambda f: f[0]) - release = parse_release_version(args.release[0]) + release = parse_release_version(args.release[0], args.staging) if verbose: print("Reading files...") pprint.pprint(list(file_index.keys())) diff --git a/generator/sbpg/targets/c.py b/generator/sbpg/targets/c.py index 2fb2aaea8f..ab88b4624d 100644 --- a/generator/sbpg/targets/c.py +++ b/generator/sbpg/targets/c.py @@ -692,5 +692,6 @@ def render_version(output_dir, release: ReleaseVersion): minor=release.minor, patch=release.patch, full_version=release.full_version, + is_staging=release.is_staging, ) ) diff --git a/generator/sbpg/targets/resources/c/sbp_version_template.h b/generator/sbpg/targets/resources/c/sbp_version_template.h index ac657a63b3..f5a23cd0c0 100644 --- a/generator/sbpg/targets/resources/c/sbp_version_template.h +++ b/generator/sbpg/targets/resources/c/sbp_version_template.h @@ -30,6 +30,9 @@ /** Full SBP version string. */ #define SBP_VERSION "(((full_version)))" +/** Is this a staging branch? */ +#define SBP_STAGING (((is_staging))) + /** \} */