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/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 7699c80af4..751645fca6 100644 Binary files a/docs/sbp.pdf and b/docs/sbp.pdf differ 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))) + /** \} */ 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