From e78aa62aede58074676e97865cb63111c7397286 Mon Sep 17 00:00:00 2001 From: fpezzinosn Date: Wed, 11 May 2022 16:38:08 -0400 Subject: [PATCH 1/3] Add leap second message [OTA-148] --- .../sbp/navigation/test_MsgGPSLeapSecond.yaml | 30 +++++++++++ spec/yaml/swiftnav/sbp/navigation.yaml | 51 +++++++++++++++++++ 2 files changed, 81 insertions(+) create mode 100644 spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSLeapSecond.yaml 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..f321f1d81b --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSLeapSecond.yaml @@ -0,0 +1,30 @@ +description: Unit tests for swiftnav.sbp.navigation MsgGPSLeapSecond +generated_on: 2022-05-11 # manually generated +package: sbp.navigation +tests: + + - msg: + fields: + bias_coeff: 1 + drift_coeff: 2 + drift_rate_coeff: 3 + count_before: 4 + tow_s: 5 + wn: 6 + ref_wn: 7 + ref_dn: 8 + count_after: 9 + module: sbp.navigation + name: MsgGPSLeapSecond + msg_type: '570' + raw_json: '{"bias_coeff": 1, "drift_coeff": 2, "drift_rate_coeff": 3, "count_before": 4, "tow_s": 5, "wn": 6, + "ref_wn": 7, "ref_dn": 8, "count_after": 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/yaml/swiftnav/sbp/navigation.yaml b/spec/yaml/swiftnav/sbp/navigation.yaml index c92066132f..f83c1277f1 100644 --- a/spec/yaml/swiftnav/sbp/navigation.yaml +++ b/spec/yaml/swiftnav/sbp/navigation.yaml @@ -2428,6 +2428,57 @@ definitions: - 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: + - bias_coeff: + type: s16 + units: 2^-35 s + desc: > + Reserved. Bias coefficient of GPS time scale with respect to UTC + drift model. + - drift_coeff: + type: s16 + units: 2^-51 s/s + desc: > + Reserved. Drift coefficient of GPS time scale with respect to UTC + drift model. + - drift_rate_coeff: + type: s8 + units: 2^-68 s/s^2 + desc: > + Reserved. Drift rate correction coefficient of GPS time scale with + respect to UTC drift model. + - count_before: + type: s8 + units: s + desc: Leap second count before insertion. + - tow_s: + type: u16 + units: s + desc: Reserved. Drift model reference week second. + - wn: + type: u16 + units: weeks + desc: Reserved. Drift model reference week number. + - ref_wn: + type: u16 + units: weeks + desc: Leap second reference week number. + - ref_dn: + type: u8 + units: days + desc: Leap second reference day number. + - count_after: + type: s8 + units: s + desc: Leap second count after insertion. + - MSG_ITRF: id: 0x0244 short_desc: Reference Frame Transformation Parameter From 13a46839f45bccd7600734b21be1c396e4e99136 Mon Sep 17 00:00:00 2001 From: fpezzinosn Date: Thu, 12 May 2022 13:57:04 -0400 Subject: [PATCH 2/3] Update number of messages --- python/tests/sbp/test_table.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/tests/sbp/test_table.py b/python/tests/sbp/test_table.py index c09dc0ccbf..29dff32539 100644 --- a/python/tests/sbp/test_table.py +++ b/python/tests/sbp/test_table.py @@ -41,7 +41,7 @@ def test_table_count(): Test number of available messages to deserialize. """ - number_of_messages = 218 + number_of_messages = 219 assert len(_SBP_TABLE) == number_of_messages def test_table_unqiue_count(): From 5e0ef33c39fa2db2e0ddc17b248abce79449d559 Mon Sep 17 00:00:00 2001 From: fpezzinosn Date: Thu, 12 May 2022 14:40:03 -0400 Subject: [PATCH 3/3] make all --- c/include/libsbp/cpp/message_traits.h | 35 +++ c/include/libsbp/legacy/cpp/message_traits.h | 6 + c/include/libsbp/legacy/navigation.h | 23 ++ c/include/libsbp/navigation_macros.h | 7 + c/include/libsbp/sbp_msg_type.h | 1 + c/include/libsbp/v4/navigation.h | 1 + .../v4/navigation/MSG_GPS_LEAP_SECOND.h | 223 ++++++++++++++++ c/include/libsbp/v4/sbp_msg.h | 12 + c/src/include/libsbp/internal/v4/navigation.h | 20 ++ c/src/v4/navigation.c | 160 ++++++++++++ ...to_check_sbp_navigation_MsgGPSLeapSecond.c | 205 +++++++++++++++ c/test/check_main.c | 1 + c/test/check_main_legacy.c | 2 + c/test/check_suites.h | 1 + c/test/check_suites_legacy.h | 1 + ...o_check_sbp_navigation_MsgGPSLeapSecond.cc | 131 ++++++++++ ...to_check_sbp_navigation_MsgGPSLeapSecond.c | 239 ++++++++++++++++++ ...o_check_sbp_navigation_MsgGPSLeapSecond.cc | 133 ++++++++++ docs/sbp.pdf | Bin 467608 -> 469371 bytes haskell/src/SwiftNav/SBP/Msg.hs | 6 + haskell/src/SwiftNav/SBP/Navigation.hs | 59 +++++ .../com/swiftnav/sbp/client/MessageTable.java | 3 + .../sbp/navigation/MsgGPSLeapSecond.java | 117 +++++++++ ...k_sbp_navigation_MsgGPSLeapSecondTest.java | 130 ++++++++++ javascript/sbp.bundle.js | 2 +- javascript/sbp/navigation.js | 55 ++++ jsonschema/MsgGPSLeapSecond.json | 40 +++ proto/navigation.proto | 18 ++ python/sbp/navigation.py | 134 ++++++++++ rust/sbp/src/messages/mod.rs | 22 ++ rust/sbp/src/messages/navigation.rs | 133 ++++++++++ ...heck_sbp_navigation_msg_gps_leap_second.rs | 95 +++++++ rust/sbp/tests/integration/main.rs | 1 + sbpjson/elm/SbpJson.elm | 51 +++- sbpjson/javascript/SbpJson.js | 22 ++ sbpjson/typescript/SbpJson.ts | 38 ++- 36 files changed, 2124 insertions(+), 3 deletions(-) create mode 100644 c/include/libsbp/v4/navigation/MSG_GPS_LEAP_SECOND.h create mode 100644 c/test/auto_check_sbp_navigation_MsgGPSLeapSecond.c create mode 100644 c/test/cpp/auto_check_sbp_navigation_MsgGPSLeapSecond.cc create mode 100644 c/test/legacy/auto_check_sbp_navigation_MsgGPSLeapSecond.c create mode 100644 c/test/legacy/cpp/auto_check_sbp_navigation_MsgGPSLeapSecond.cc create mode 100644 java/src/com/swiftnav/sbp/navigation/MsgGPSLeapSecond.java create mode 100644 java/test/auto_check_sbp_navigation_MsgGPSLeapSecondTest.java create mode 100644 jsonschema/MsgGPSLeapSecond.json create mode 100644 rust/sbp/tests/integration/auto_check_sbp_navigation_msg_gps_leap_second.rs diff --git a/c/include/libsbp/cpp/message_traits.h b/c/include/libsbp/cpp/message_traits.h index 3e689e61e7..e1c7054f73 100644 --- a/c/include/libsbp/cpp/message_traits.h +++ b/c/include/libsbp/cpp/message_traits.h @@ -2688,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; diff --git a/c/include/libsbp/legacy/cpp/message_traits.h b/c/include/libsbp/legacy/cpp/message_traits.h index 150af8d2b9..0d3549f8c1 100644 --- a/c/include/libsbp/legacy/cpp/message_traits.h +++ b/c/include/libsbp/legacy/cpp/message_traits.h @@ -913,6 +913,12 @@ struct MessageTraits { }; +template<> +struct MessageTraits { + static constexpr u16 id = 570; +}; + + template<> struct MessageTraits { static constexpr u16 id = 580; diff --git a/c/include/libsbp/legacy/navigation.h b/c/include/libsbp/legacy/navigation.h index 8002b3b6a2..b3817150e6 100644 --- a/c/include/libsbp/legacy/navigation.h +++ b/c/include/libsbp/legacy/navigation.h @@ -919,6 +919,29 @@ 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 { + s16 bias_coeff; /**< Reserved. Bias coefficient of GPS time scale + with respect to UTC drift model. [2^-35 s] */ + s16 drift_coeff; /**< Reserved. Drift coefficient of GPS time scale + with respect to UTC drift model. [2^-51 s/s] */ + s8 drift_rate_coeff; /**< Reserved. Drift rate correction coefficient of + GPS time scale with respect to UTC drift model. + [2^-68 s/s^2] */ + s8 count_before; /**< Leap second count before insertion. [s] */ + u16 tow_s; /**< Reserved. Drift model reference week second. [s] */ + u16 wn; /**< Reserved. Drift model reference week number. [weeks] */ + u16 ref_wn; /**< Leap second reference week number. [weeks] */ + u8 ref_dn; /**< Leap second reference day number. [days] */ + s8 count_after; /**< Leap second count after insertion. [s] */ +} msg_gps_leap_second_t; + typedef struct SBP_ATTR_PACKED { u8 ssr_iod; /**< SSR IOD parameter. */ u8 sn_counter_n; /**< Source-Name Counter N. */ diff --git a/c/include/libsbp/navigation_macros.h b/c/include/libsbp/navigation_macros.h index a65f792046..ac018e5af7 100644 --- a/c/include/libsbp/navigation_macros.h +++ b/c/include/libsbp/navigation_macros.h @@ -1736,6 +1736,13 @@ */ #define SBP_MSG_PROTECTION_LEVEL_ENCODED_LEN 76u +#define SBP_MSG_GPS_LEAP_SECOND 0x023A +/** + * Encoded length of sbp_msg_gps_leap_second_t (V4 API) and + * msg_gps_leap_second_t (legacy API) + */ +#define SBP_MSG_GPS_LEAP_SECOND_ENCODED_LEN 14u + #define SBP_MSG_ITRF 0x0244 /** * The maximum number of items that can be stored in sbp_msg_itrf_t::sn (V4 API) diff --git a/c/include/libsbp/sbp_msg_type.h b/c/include/libsbp/sbp_msg_type.h index 4c58fe9b10..1be546c6e4 100644 --- a/c/include/libsbp/sbp_msg_type.h +++ b/c/include/libsbp/sbp_msg_type.h @@ -127,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, diff --git a/c/include/libsbp/v4/navigation.h b/c/include/libsbp/v4/navigation.h index 0b46e71927..f61fd07640 100644 --- a/c/include/libsbp/v4/navigation.h +++ b/c/include/libsbp/v4/navigation.h @@ -26,6 +26,7 @@ #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..35dc956dc3 --- /dev/null +++ b/c/include/libsbp/v4/navigation/MSG_GPS_LEAP_SECOND.h @@ -0,0 +1,223 @@ +/* + * 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 { + /** + * Reserved. Bias coefficient of GPS time scale with respect to UTC drift + * model. [2^-35 s] + */ + s16 bias_coeff; + + /** + * Reserved. Drift coefficient of GPS time scale with respect to UTC drift + * model. [2^-51 s/s] + */ + s16 drift_coeff; + + /** + * Reserved. Drift rate correction coefficient of GPS time scale with respect + * to UTC drift model. [2^-68 s/s^2] + */ + s8 drift_rate_coeff; + + /** + * Leap second count before insertion. [s] + */ + s8 count_before; + + /** + * Reserved. Drift model reference week second. [s] + */ + u16 tow_s; + + /** + * Reserved. Drift model reference week number. [weeks] + */ + u16 wn; + + /** + * Leap second reference week number. [weeks] + */ + u16 ref_wn; + + /** + * Leap second reference day number. [days] + */ + u8 ref_dn; + + /** + * Leap second count after insertion. [s] + */ + s8 count_after; +} 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) { + (void)msg; + return SBP_MSG_GPS_LEAP_SECOND_ENCODED_LEN; +} + +/** + * 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/sbp_msg.h b/c/include/libsbp/v4/sbp_msg.h index 8f8a73eb4d..f8428fbbc1 100644 --- a/c/include/libsbp/v4/sbp_msg.h +++ b/c/include/libsbp/v4/sbp_msg.h @@ -133,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; @@ -508,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); @@ -1119,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); @@ -1672,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: @@ -2205,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: diff --git a/c/src/include/libsbp/internal/v4/navigation.h b/c/src/include/libsbp/internal/v4/navigation.h index 6f7e403680..213d878b87 100644 --- a/c/src/include/libsbp/internal/v4/navigation.h +++ b/c/src/include/libsbp/internal/v4/navigation.h @@ -806,6 +806,26 @@ 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 * diff --git a/c/src/v4/navigation.c b/c/src/v4/navigation.c index 1d56ee2068..7872747b90 100644 --- a/c/src/v4/navigation.c +++ b/c/src/v4/navigation.c @@ -5972,6 +5972,166 @@ 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) { + if (!sbp_s16_encode(ctx, &msg->bias_coeff)) { + return false; + } + if (!sbp_s16_encode(ctx, &msg->drift_coeff)) { + return false; + } + if (!sbp_s8_encode(ctx, &msg->drift_rate_coeff)) { + return false; + } + if (!sbp_s8_encode(ctx, &msg->count_before)) { + return false; + } + if (!sbp_u16_encode(ctx, &msg->tow_s)) { + return false; + } + if (!sbp_u16_encode(ctx, &msg->wn)) { + return false; + } + if (!sbp_u16_encode(ctx, &msg->ref_wn)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->ref_dn)) { + return false; + } + if (!sbp_s8_encode(ctx, &msg->count_after)) { + 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) { + if (!sbp_s16_decode(ctx, &msg->bias_coeff)) { + return false; + } + if (!sbp_s16_decode(ctx, &msg->drift_coeff)) { + return false; + } + if (!sbp_s8_decode(ctx, &msg->drift_rate_coeff)) { + return false; + } + if (!sbp_s8_decode(ctx, &msg->count_before)) { + return false; + } + if (!sbp_u16_decode(ctx, &msg->tow_s)) { + return false; + } + if (!sbp_u16_decode(ctx, &msg->wn)) { + return false; + } + if (!sbp_u16_decode(ctx, &msg->ref_wn)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->ref_dn)) { + return false; + } + if (!sbp_s8_decode(ctx, &msg->count_after)) { + 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_s16_cmp(&a->bias_coeff, &b->bias_coeff); + if (ret != 0) { + return ret; + } + + ret = sbp_s16_cmp(&a->drift_coeff, &b->drift_coeff); + if (ret != 0) { + return ret; + } + + ret = sbp_s8_cmp(&a->drift_rate_coeff, &b->drift_rate_coeff); + if (ret != 0) { + return ret; + } + + ret = sbp_s8_cmp(&a->count_before, &b->count_before); + if (ret != 0) { + return ret; + } + + ret = sbp_u16_cmp(&a->tow_s, &b->tow_s); + if (ret != 0) { + return ret; + } + + ret = sbp_u16_cmp(&a->wn, &b->wn); + if (ret != 0) { + return ret; + } + + ret = sbp_u16_cmp(&a->ref_wn, &b->ref_wn); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->ref_dn, &b->ref_dn); + if (ret != 0) { + return ret; + } + + ret = sbp_s8_cmp(&a->count_after, &b->count_after); + if (ret != 0) { + return ret; + } + return ret; +} + bool sbp_msg_itrf_encode_internal(sbp_encode_ctx_t *ctx, const sbp_msg_itrf_t *msg) { if (!sbp_u8_encode(ctx, &msg->ssr_iod)) { 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..2d6903d252 --- /dev/null +++ b/c/test/auto_check_sbp_navigation_MsgGPSLeapSecond.c @@ -0,0 +1,205 @@ +/* + * 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.bias_coeff = 1; + + test_msg.gps_leap_second.count_after = 9; + + test_msg.gps_leap_second.count_before = 4; + + test_msg.gps_leap_second.drift_coeff = 2; + + test_msg.gps_leap_second.drift_rate_coeff = 3; + + test_msg.gps_leap_second.ref_dn = 8; + + test_msg.gps_leap_second.ref_wn = 7; + + test_msg.gps_leap_second.tow_s = 5; + + test_msg.gps_leap_second.wn = 6; + + 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.bias_coeff == 1, + "incorrect value for " + "last_msg.msg.gps_leap_second.bias_coeff, expected 1, is %d", + last_msg.msg.gps_leap_second.bias_coeff); + + ck_assert_msg(last_msg.msg.gps_leap_second.count_after == 9, + "incorrect value for " + "last_msg.msg.gps_leap_second.count_after, expected 9, is %d", + last_msg.msg.gps_leap_second.count_after); + + ck_assert_msg( + last_msg.msg.gps_leap_second.count_before == 4, + "incorrect value for last_msg.msg.gps_leap_second.count_before, " + "expected 4, is %d", + last_msg.msg.gps_leap_second.count_before); + + ck_assert_msg(last_msg.msg.gps_leap_second.drift_coeff == 2, + "incorrect value for " + "last_msg.msg.gps_leap_second.drift_coeff, expected 2, is %d", + last_msg.msg.gps_leap_second.drift_coeff); + + ck_assert_msg( + last_msg.msg.gps_leap_second.drift_rate_coeff == 3, + "incorrect value for last_msg.msg.gps_leap_second.drift_rate_coeff, " + "expected 3, is %d", + last_msg.msg.gps_leap_second.drift_rate_coeff); + + ck_assert_msg(last_msg.msg.gps_leap_second.ref_dn == 8, + "incorrect value for last_msg.msg.gps_leap_second.ref_dn, " + "expected 8, is %d", + last_msg.msg.gps_leap_second.ref_dn); + + ck_assert_msg(last_msg.msg.gps_leap_second.ref_wn == 7, + "incorrect value for last_msg.msg.gps_leap_second.ref_wn, " + "expected 7, is %d", + last_msg.msg.gps_leap_second.ref_wn); + + ck_assert_msg(last_msg.msg.gps_leap_second.tow_s == 5, + "incorrect value for last_msg.msg.gps_leap_second.tow_s, " + "expected 5, is %d", + last_msg.msg.gps_leap_second.tow_s); + + ck_assert_msg(last_msg.msg.gps_leap_second.wn == 6, + "incorrect value for last_msg.msg.gps_leap_second.wn, " + "expected 6, is %d", + last_msg.msg.gps_leap_second.wn); + } +} +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/check_main.c b/c/test/check_main.c index bc6b9af02a..79ee60c34e 100644 --- a/c/test/check_main.c +++ b/c/test/check_main.c @@ -54,6 +54,7 @@ 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()); diff --git a/c/test/check_main_legacy.c b/c/test/check_main_legacy.c index e8c4f330c4..a76b0e6fee 100644 --- a/c/test/check_main_legacy.c +++ b/c/test/check_main_legacy.c @@ -66,6 +66,8 @@ 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()); diff --git a/c/test/check_suites.h b/c/test/check_suites.h index 6d3bf7dc18..1122423621 100644 --- a/c/test/check_suites.h +++ b/c/test/check_suites.h @@ -42,6 +42,7 @@ 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); diff --git a/c/test/check_suites_legacy.h b/c/test/check_suites_legacy.h index 2991203bd5..f18f0e3281 100644 --- a/c/test/check_suites_legacy.h +++ b/c/test/check_suites_legacy.h @@ -43,6 +43,7 @@ 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); 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..6a94c19a8c --- /dev/null +++ b/c/test/cpp/auto_check_sbp_navigation_MsgGPSLeapSecond.cc @@ -0,0 +1,131 @@ +/* + * 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.bias_coeff = 1; + test_msg.count_after = 9; + test_msg.count_before = 4; + test_msg.drift_coeff = 2; + test_msg.drift_rate_coeff = 3; + test_msg.ref_dn = 8; + test_msg.ref_wn = 7; + test_msg.tow_s = 5; + test_msg.wn = 6; + + 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_.bias_coeff, 1) + << "incorrect value for last_msg_.bias_coeff, expected 1, is " + << last_msg_.bias_coeff; + EXPECT_EQ(last_msg_.count_after, 9) + << "incorrect value for last_msg_.count_after, expected 9, is " + << last_msg_.count_after; + EXPECT_EQ(last_msg_.count_before, 4) + << "incorrect value for last_msg_.count_before, expected 4, is " + << last_msg_.count_before; + EXPECT_EQ(last_msg_.drift_coeff, 2) + << "incorrect value for last_msg_.drift_coeff, expected 2, is " + << last_msg_.drift_coeff; + EXPECT_EQ(last_msg_.drift_rate_coeff, 3) + << "incorrect value for last_msg_.drift_rate_coeff, expected 3, is " + << last_msg_.drift_rate_coeff; + EXPECT_EQ(last_msg_.ref_dn, 8) + << "incorrect value for last_msg_.ref_dn, expected 8, is " + << last_msg_.ref_dn; + EXPECT_EQ(last_msg_.ref_wn, 7) + << "incorrect value for last_msg_.ref_wn, expected 7, is " + << last_msg_.ref_wn; + EXPECT_EQ(last_msg_.tow_s, 5) + << "incorrect value for last_msg_.tow_s, expected 5, is " + << last_msg_.tow_s; + EXPECT_EQ(last_msg_.wn, 6) + << "incorrect value for last_msg_.wn, expected 6, is " << last_msg_.wn; +} 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..d1c481b19e --- /dev/null +++ b/c/test/legacy/auto_check_sbp_navigation_MsgGPSLeapSecond.c @@ -0,0 +1,239 @@ +/* + * 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); + test_msg->bias_coeff = 1; + test_msg->count_after = 9; + test_msg->count_before = 4; + test_msg->drift_coeff = 2; + test_msg->drift_rate_coeff = 3; + test_msg->ref_dn = 8; + test_msg->ref_wn = 7; + test_msg->tow_s = 5; + test_msg->wn = 6; + 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->bias_coeff == 1, + "incorrect value for bias_coeff, expected 1, is %d", + check_msg->bias_coeff); + ck_assert_msg(check_msg->count_after == 9, + "incorrect value for count_after, expected 9, is %d", + check_msg->count_after); + ck_assert_msg(check_msg->count_before == 4, + "incorrect value for count_before, expected 4, is %d", + check_msg->count_before); + ck_assert_msg(check_msg->drift_coeff == 2, + "incorrect value for drift_coeff, expected 2, is %d", + check_msg->drift_coeff); + ck_assert_msg(check_msg->drift_rate_coeff == 3, + "incorrect value for drift_rate_coeff, expected 3, is %d", + check_msg->drift_rate_coeff); + ck_assert_msg(check_msg->ref_dn == 8, + "incorrect value for ref_dn, expected 8, is %d", + check_msg->ref_dn); + ck_assert_msg(check_msg->ref_wn == 7, + "incorrect value for ref_wn, expected 7, is %d", + check_msg->ref_wn); + ck_assert_msg(check_msg->tow_s == 5, + "incorrect value for tow_s, expected 5, is %d", + check_msg->tow_s); + ck_assert_msg(check_msg->wn == 6, + "incorrect value for wn, expected 6, is %d", check_msg->wn); + } +} +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/cpp/auto_check_sbp_navigation_MsgGPSLeapSecond.cc b/c/test/legacy/cpp/auto_check_sbp_navigation_MsgGPSLeapSecond.cc new file mode 100644 index 0000000000..b11d6f0a23 --- /dev/null +++ b/c/test/legacy/cpp/auto_check_sbp_navigation_MsgGPSLeapSecond.cc @@ -0,0 +1,133 @@ +/* + * 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); + test_msg->bias_coeff = 1; + test_msg->count_after = 9; + test_msg->count_before = 4; + test_msg->drift_coeff = 2; + test_msg->drift_rate_coeff = 3; + test_msg->ref_dn = 8; + test_msg->ref_wn = 7; + test_msg->tow_s = 5; + test_msg->wn = 6; + + 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_->bias_coeff, 1) + << "incorrect value for bias_coeff, expected 1, is " + << last_msg_->bias_coeff; + EXPECT_EQ(last_msg_->count_after, 9) + << "incorrect value for count_after, expected 9, is " + << last_msg_->count_after; + EXPECT_EQ(last_msg_->count_before, 4) + << "incorrect value for count_before, expected 4, is " + << last_msg_->count_before; + EXPECT_EQ(last_msg_->drift_coeff, 2) + << "incorrect value for drift_coeff, expected 2, is " + << last_msg_->drift_coeff; + EXPECT_EQ(last_msg_->drift_rate_coeff, 3) + << "incorrect value for drift_rate_coeff, expected 3, is " + << last_msg_->drift_rate_coeff; + EXPECT_EQ(last_msg_->ref_dn, 8) + << "incorrect value for ref_dn, expected 8, is " << last_msg_->ref_dn; + EXPECT_EQ(last_msg_->ref_wn, 7) + << "incorrect value for ref_wn, expected 7, is " << last_msg_->ref_wn; + EXPECT_EQ(last_msg_->tow_s, 5) + << "incorrect value for tow_s, expected 5, is " << last_msg_->tow_s; + EXPECT_EQ(last_msg_->wn, 6) + << "incorrect value for wn, expected 6, is " << last_msg_->wn; +} diff --git a/docs/sbp.pdf b/docs/sbp.pdf index 2708a03b8e2a515433a284dada5b05359380ae0b..53673f2be1adb3d97a71d0fd789193adda44b321 100644 GIT binary patch delta 104383 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 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 @@ -1041,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 @@ -1263,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 diff --git a/haskell/src/SwiftNav/SBP/Navigation.hs b/haskell/src/SwiftNav/SBP/Navigation.hs index 63b431f8fb..a8e9aadbd3 100644 --- a/haskell/src/SwiftNav/SBP/Navigation.hs +++ b/haskell/src/SwiftNav/SBP/Navigation.hs @@ -2304,6 +2304,65 @@ $(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_bias_coeff :: !Int16 + -- ^ Reserved. Bias coefficient of GPS time scale with respect to UTC drift + -- model. + , _msgGpsLeapSecond_drift_coeff :: !Int16 + -- ^ Reserved. Drift coefficient of GPS time scale with respect to UTC drift + -- model. + , _msgGpsLeapSecond_drift_rate_coeff :: !Int8 + -- ^ Reserved. Drift rate correction coefficient of GPS time scale with + -- respect to UTC drift model. + , _msgGpsLeapSecond_count_before :: !Int8 + -- ^ Leap second count before insertion. + , _msgGpsLeapSecond_tow_s :: !Word16 + -- ^ Reserved. Drift model reference week second. + , _msgGpsLeapSecond_wn :: !Word16 + -- ^ Reserved. Drift model reference week number. + , _msgGpsLeapSecond_ref_wn :: !Word16 + -- ^ Leap second reference week number. + , _msgGpsLeapSecond_ref_dn :: !Word8 + -- ^ Leap second reference day number. + , _msgGpsLeapSecond_count_after :: !Int8 + -- ^ Leap second count after insertion. + } deriving ( Show, Read, Eq ) + +instance Binary MsgGpsLeapSecond where + get = do + _msgGpsLeapSecond_bias_coeff <- (fromIntegral <$> getWord16le) + _msgGpsLeapSecond_drift_coeff <- (fromIntegral <$> getWord16le) + _msgGpsLeapSecond_drift_rate_coeff <- (fromIntegral <$> getWord8) + _msgGpsLeapSecond_count_before <- (fromIntegral <$> getWord8) + _msgGpsLeapSecond_tow_s <- getWord16le + _msgGpsLeapSecond_wn <- getWord16le + _msgGpsLeapSecond_ref_wn <- getWord16le + _msgGpsLeapSecond_ref_dn <- getWord8 + _msgGpsLeapSecond_count_after <- (fromIntegral <$> getWord8) + pure MsgGpsLeapSecond {..} + + put MsgGpsLeapSecond {..} = do + (putWord16le . fromIntegral) _msgGpsLeapSecond_bias_coeff + (putWord16le . fromIntegral) _msgGpsLeapSecond_drift_coeff + (putWord8 . fromIntegral) _msgGpsLeapSecond_drift_rate_coeff + (putWord8 . fromIntegral) _msgGpsLeapSecond_count_before + putWord16le _msgGpsLeapSecond_tow_s + putWord16le _msgGpsLeapSecond_wn + putWord16le _msgGpsLeapSecond_ref_wn + putWord8 _msgGpsLeapSecond_ref_dn + (putWord8 . fromIntegral) _msgGpsLeapSecond_count_after + +$(makeSBP 'msgGpsLeapSecond ''MsgGpsLeapSecond) +$(makeJSON "_msgGpsLeapSecond_" ''MsgGpsLeapSecond) +$(makeLenses ''MsgGpsLeapSecond) + msgItrf :: Word16 msgItrf = 0x0244 diff --git a/java/src/com/swiftnav/sbp/client/MessageTable.java b/java/src/com/swiftnav/sbp/client/MessageTable.java index 398c4d3f39..336cd19b2f 100644 --- a/java/src/com/swiftnav/sbp/client/MessageTable.java +++ b/java/src/com/swiftnav/sbp/client/MessageTable.java @@ -76,6 +76,7 @@ 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; @@ -421,6 +422,8 @@ 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: 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..fb942e107b --- /dev/null +++ b/java/src/com/swiftnav/sbp/navigation/MsgGPSLeapSecond.java @@ -0,0 +1,117 @@ +/* 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.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; + + /** Reserved. Bias coefficient of GPS time scale with respect to UTC drift model. */ + public int bias_coeff; + + /** Reserved. Drift coefficient of GPS time scale with respect to UTC drift model. */ + public int drift_coeff; + + /** + * Reserved. Drift rate correction coefficient of GPS time scale with respect to UTC drift + * model. + */ + public int drift_rate_coeff; + + /** Leap second count before insertion. */ + public int count_before; + + /** Reserved. Drift model reference week second. */ + public int tow_s; + + /** Reserved. Drift model reference week number. */ + public int wn; + + /** Leap second reference week number. */ + public int ref_wn; + + /** Leap second reference day number. */ + public int ref_dn; + + /** Leap second count after insertion. */ + public int count_after; + + 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 */ + bias_coeff = parser.getS16(); + drift_coeff = parser.getS16(); + drift_rate_coeff = parser.getS8(); + count_before = parser.getS8(); + tow_s = parser.getU16(); + wn = parser.getU16(); + ref_wn = parser.getU16(); + ref_dn = parser.getU8(); + count_after = parser.getS8(); + } + + @Override + protected void build(Builder builder) { + builder.putS16(bias_coeff); + builder.putS16(drift_coeff); + builder.putS8(drift_rate_coeff); + builder.putS8(count_before); + builder.putU16(tow_s); + builder.putU16(wn); + builder.putU16(ref_wn); + builder.putU8(ref_dn); + builder.putS8(count_after); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("bias_coeff", bias_coeff); + obj.put("drift_coeff", drift_coeff); + obj.put("drift_rate_coeff", drift_rate_coeff); + obj.put("count_before", count_before); + obj.put("tow_s", tow_s); + obj.put("wn", wn); + obj.put("ref_wn", ref_wn); + obj.put("ref_dn", ref_dn); + obj.put("count_after", count_after); + return obj; + } +} 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..89679f9942 --- /dev/null +++ b/java/test/auto_check_sbp_navigation_MsgGPSLeapSecondTest.java @@ -0,0 +1,130 @@ +/* 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.bias_coeff; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.bias_coeff + "' != '" + 1 + "'", + value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.count_after; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.count_after + "' != '" + 9 + "'", + value.equals(BigInteger.valueOf(9L))); + } else { + value = value.longValue(); + expected = 9L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.count_before; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.count_before + "' != '" + 4 + "'", + value.equals(BigInteger.valueOf(4L))); + } else { + value = value.longValue(); + expected = 4L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.drift_coeff; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.drift_coeff + "' != '" + 2 + "'", + value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.drift_rate_coeff; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.drift_rate_coeff + "' != '" + 3 + "'", + value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.ref_dn; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.ref_dn + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + } else { + value = value.longValue(); + expected = 8L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.ref_wn; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.ref_wn + "' != '" + 7 + "'", value.equals(BigInteger.valueOf(7L))); + } else { + value = value.longValue(); + expected = 7L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.tow_s; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.tow_s + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + } else { + value = value.longValue(); + expected = 5L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.wn; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.wn + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + } else { + value = value.longValue(); + expected = 6L; + org.junit.Assert.assertEquals(value, expected); + } + } +} diff --git a/javascript/sbp.bundle.js b/javascript/sbp.bundle.js index 13278e5afa..b9cf4f5cbc 100644 --- a/javascript/sbp.bundle.js +++ b/javascript/sbp.bundle.js @@ -12,4 +12,4 @@ var r=p(25),o=p(26),i=p(16);function s(){return a.TYPED_ARRAY_SUPPORT?2147483647 * @author Feross Aboukhadijeh * @license MIT */ -function r(e,t){if(e===t)return 0;for(var p=e.length,r=t.length,o=0,i=Math.min(p,r);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],p,r))return!1;return!0}(e,t,p,s))}return p?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,p,r){var o;if("function"!=typeof t)throw new TypeError('"block" argument must be a function');"string"==typeof p&&(r=p,p=null),o=function(e){var t;try{e()}catch(e){t=e}return t}(t),r=(p&&p.name?" ("+p.name+").":".")+(r?" "+r:"."),e&&!o&&_(o,p,"Missing expected exception"+r);var s="string"==typeof r,n=!e&&o&&!p;if((!e&&i.isError(o)&&s&&E(o,p)||n)&&_(o,p,"Got unwanted exception"+r),e&&o&&p&&!E(o,p)||!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 p=new Error;if(p.stack){var r=p.stack,o=h(t),i=r.indexOf("\n"+o);if(i>=0){var s=r.indexOf("\n",i+1);r=r.substring(s+1)}this.stack=r}}},i.inherits(u.AssertionError,Error),u.fail=_,u.ok=S,u.equal=function(e,t,p){e!=t&&_(e,t,p,"==",u.equal)},u.notEqual=function(e,t,p){e==t&&_(e,t,p,"!=",u.notEqual)},u.deepEqual=function(e,t,p){g(e,t,!1)||_(e,t,p,"deepEqual",u.deepEqual)},u.deepStrictEqual=function(e,t,p){g(e,t,!0)||_(e,t,p,"deepStrictEqual",u.deepStrictEqual)},u.notDeepEqual=function(e,t,p){g(e,t,!1)&&_(e,t,p,"notDeepEqual",u.notDeepEqual)},u.notDeepStrictEqual=function e(t,p,r){g(t,p,!0)&&_(t,p,r,"notDeepStrictEqual",e)},u.strictEqual=function(e,t,p){e!==t&&_(e,t,p,"===",u.strictEqual)},u.notStrictEqual=function(e,t,p){e===t&&_(e,t,p,"!==",u.notStrictEqual)},u.throws=function(e,t,p){m(!0,e,t,p)},u.doesNotThrow=function(e,t,p){m(!1,e,t,p)},u.ifError=function(e){if(e)throw e};var b=Object.keys||function(e){var t=[];for(var p in e)s.call(e,p)&&t.push(p);return t}}).call(this,p(5))},function(e,t,p){var r;!function(p){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 p=parseInt(e,t||10);return this._low=65535&p,this._high=p>>>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,p=t>>>16;return p+=this._high+e._high,this._low=65535&t,this._high=65535&p,this},o.prototype.subtract=function(e){return this.add(e.clone().negate())},o.prototype.multiply=function(e){var t,p,r=this._high,o=this._low,i=e._high,s=e._low;return t=(p=o*s)>>>16,t+=r*s,t&=65535,t+=o*i,this._low=65535&p,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(),p=-1;!this.lt(t);)t.shiftLeft(1,!0),p++;for(this.remainder=this.clone(),this._low=0,this._high=0;p>=0;p--)t.shiftRight(1),this.remainder.lt(t)||(this.remainder.subtract(t),p>=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===(r=function(){return o}.apply(t,[]))||(e.exports=r)}()},function(e,t,p){var r;!function(p){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,p,r){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,p,r)}function n(e,t,p,r){return void 0===p?(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|p,this._a48=0|r,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 p=o[t]||new s(Math.pow(t,5)),r=0,i=e.length;r=0&&(p.div(t),r[o]=p.remainder.toNumber().toString(e),p.gt(t));o--);return r[o-1]=p.toNumber().toString(e),r.join("")},s.prototype.add=function(e){var t=this._a00+e._a00,p=t>>>16,r=(p+=this._a16+e._a16)>>>16,o=(r+=this._a32+e._a32)>>>16;return o+=this._a48+e._a48,this._a00=65535&t,this._a16=65535&p,this._a32=65535&r,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,p=this._a16,r=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+=p*i)>>>16;var u=(c+=t*n)>>>16;return c&=65535,u+=(c+=p*s)>>>16,c&=65535,u+=(c+=r*i)>>>16,u+=t*e._a48,u&=65535,u+=p*n,u&=65535,u+=r*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(),p=-1;!this.lt(t);)t.shiftLeft(1,!0),p++;for(this.remainder=this.clone(),this._a00=0,this._a16=0,this._a32=0,this._a48=0;p>=0;p--)t.shiftRight(1),this.remainder.lt(t)||(this.remainder.subtract(t),p>=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 p=this._a48<<16|this._a32,r=this._a16<<16|this._a00,o=p<>>32-e,i=r<>>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 p=this._a48<<16|this._a32,r=this._a16<<16|this._a00,o=p>>>e|r<<32-e,i=r>>>e|p<<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===(r=function(){return s}.apply(t,[]))||(e.exports=r)}()},function(e,t,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=p(0).GnssSignalDep,n=(p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec,p(0).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_RESULT",this.fields=t||this.parser.parse(e.payload),this});(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="AcqSvProfile",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="AcqSvProfileDep",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ACQ_SV_PROFILE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ACQ_SV_PROFILE_DEP",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_REQ",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_RESP",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BOOTLOADER_JUMP_TO_APP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_NAP_DEVICE_DNA_REQ",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_NAP_DEVICE_DNA_RESP",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_EXT_EVENT",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_READ_REQ",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FILEIO_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FILEIO_READ_DIR_REQ",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FILEIO_READ_DIR_RESP",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FILEIO_REMOVE",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FILEIO_WRITE_REQ",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FILEIO_WRITE_RESP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FILEIO_CONFIG_REQ",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FILEIO_CONFIG_RESP",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_FLASH_PROGRAM",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FLASH_DONE",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FLASH_READ_REQ",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FLASH_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FLASH_ERASE",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_STM_FLASH_LOCK_SECTOR",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_STM_FLASH_UNLOCK_SECTOR",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_STM_UNIQUE_ID_REQ",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_STM_UNIQUE_ID_RESP",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_M25_FLASH_WRITE_STATUS",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_IMU_RAW",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_IMU_AUX",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal,p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec),s=p(0).SvId,n=function(e,t){return r.call(this,e),this.messageType="IntegritySSRHeader",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="IntegritySSRHeader",n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").nest("obs_time",{type:i.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("ssr_sol_id").uint16("tile_set_id").uint16("tile_id").uint8("chain_id"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["obs_time",i.prototype.fieldSpec]),n.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),n.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),n.prototype.fieldSpec.push(["ssr_sol_id","writeUInt8",1]),n.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),n.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),n.prototype.fieldSpec.push(["chain_id","writeUInt8",1]);var a=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_HIGH_LEVEL",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_HIGH_LEVEL",a.prototype.msg_type=3001,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").nest("obs_time",{type:i.prototype.parser}).nest("corr_time",{type:i.prototype.parser}).uint8("ssr_sol_id").uint16("tile_set_id").uint16("tile_id").uint8("chain_id").uint8("use_gps_sat").uint8("use_gal_sat").uint8("use_bds_sat").array("reserved",{length:6,type:"uint8"}).uint8("use_tropo_grid_points").uint8("use_iono_grid_points").uint8("use_iono_tile_sat_los").uint8("use_iono_grid_point_sat_los"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["obs_time",i.prototype.fieldSpec]),a.prototype.fieldSpec.push(["corr_time",i.prototype.fieldSpec]),a.prototype.fieldSpec.push(["ssr_sol_id","writeUInt8",1]),a.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),a.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),a.prototype.fieldSpec.push(["chain_id","writeUInt8",1]),a.prototype.fieldSpec.push(["use_gps_sat","writeUInt8",1]),a.prototype.fieldSpec.push(["use_gal_sat","writeUInt8",1]),a.prototype.fieldSpec.push(["use_bds_sat","writeUInt8",1]),a.prototype.fieldSpec.push(["reserved","array","writeUInt8",function(){return 1},6]),a.prototype.fieldSpec.push(["use_tropo_grid_points","writeUInt8",1]),a.prototype.fieldSpec.push(["use_iono_grid_points","writeUInt8",1]),a.prototype.fieldSpec.push(["use_iono_tile_sat_los","writeUInt8",1]),a.prototype.fieldSpec.push(["use_iono_grid_point_sat_los","writeUInt8",1]);var l=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_SATELLITES",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_SATELLITES",l.prototype.msg_type=3005,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").nest("obs_time",{type:i.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("ssr_sol_id").uint8("chain_id").uint8("const_id").uint8("n_faulty_sats").array("faulty_sats",{type:"uint8",length:"n_faulty_sats"}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["obs_time",i.prototype.fieldSpec]),l.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),l.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),l.prototype.fieldSpec.push(["ssr_sol_id","writeUInt8",1]),l.prototype.fieldSpec.push(["chain_id","writeUInt8",1]),l.prototype.fieldSpec.push(["const_id","writeUInt8",1]),l.prototype.fieldSpec.push(["n_faulty_sats","writeUInt8",1]),l.prototype.fieldSpec.push(["faulty_sats","array","writeUInt8",function(){return 1},"n_faulty_sats"]);var c=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_TROPO_GRID_POINTS",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_TROPO_GRID_POINTS",c.prototype.msg_type=3011,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").nest("header",{type:n.prototype.parser}).uint8("n_faulty_points").array("faulty_points",{type:"uint16le",length:"n_faulty_points"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),c.prototype.fieldSpec.push(["n_faulty_points","writeUInt8",1]),c.prototype.fieldSpec.push(["faulty_points","array","writeUInt16LE",function(){return 2},"n_faulty_points"]);var u=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_IONO_GRID_POINTS",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_IONO_GRID_POINTS",u.prototype.msg_type=3015,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").nest("header",{type:n.prototype.parser}).uint8("n_faulty_points").array("faulty_points",{type:"uint16le",length:"n_faulty_points"}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),u.prototype.fieldSpec.push(["n_faulty_points","writeUInt8",1]),u.prototype.fieldSpec.push(["faulty_points","array","writeUInt16LE",function(){return 2},"n_faulty_points"]);var y=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_IONO_TILE_SAT_LOS",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_IONO_TILE_SAT_LOS",y.prototype.msg_type=3021,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").nest("header",{type:n.prototype.parser}).uint8("n_faulty_los").array("faulty_los",{type:s.prototype.parser,length:"n_faulty_los"}),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),y.prototype.fieldSpec.push(["n_faulty_los","writeUInt8",1]),y.prototype.fieldSpec.push(["faulty_los","array",s.prototype.fieldSpec,function(){return this.fields.array.length},"n_faulty_los"]);var h=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS",h.prototype.msg_type=3025,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").nest("header",{type:n.prototype.parser}).uint16("grid_point_id").uint8("n_faulty_los").array("faulty_los",{type:s.prototype.parser,length:"n_faulty_los"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),h.prototype.fieldSpec.push(["grid_point_id","writeUInt16LE",2]),h.prototype.fieldSpec.push(["n_faulty_los","writeUInt8",1]),h.prototype.fieldSpec.push(["faulty_los","array",s.prototype.fieldSpec,function(){return this.fields.array.length},"n_faulty_los"]),e.exports={IntegritySSRHeader:n,3001:a,MsgSsrFlagHighLevel:a,3005:l,MsgSsrFlagSatellites:l,3011:c,MsgSsrFlagTropoGridPoints:c,3015:u,MsgSsrFlagIonoGridPoints:u,3021:y,MsgSsrFlagIonoTileSatLos:y,3025:h,MsgSsrFlagIonoGridPointSatLos:h}},function(e,t,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_CPU_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_MEM_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_SYS_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_PROCESS_SOCKET_COUNTS",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_PROCESS_SOCKET_QUEUES",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_SOCKET_USAGE",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_PROCESS_FD_COUNT",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_PROCESS_FD_SUMMARY",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_CPU_STATE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_MEM_STATE",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_SYS_STATE",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_LOG",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FWD",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_PRINT_DEP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_MAG_RAW",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_GPS_TIME",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_GPS_TIME_GNSS",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_UTC_TIME",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_UTC_TIME_GNSS",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_DOPS",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_POS_ECEF",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_POS_ECEF_COV",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_POS_LLH",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_POS_LLH_COV",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="EstimatedHorizontalErrorEllipse",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_POS_LLH_ACC",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BASELINE_ECEF",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BASELINE_NED",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_ECEF",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_ECEF_COV",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_NED",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_NED_COV",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_POS_ECEF_GNSS",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.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 I=function(e,t){return r.call(this,e),this.messageType="MSG_POS_ECEF_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="MSG_POS_ECEF_COV_GNSS",I.prototype.msg_type=564,I.prototype.constructor=I,I.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"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),I.prototype.fieldSpec.push(["x","writeDoubleLE",8]),I.prototype.fieldSpec.push(["y","writeDoubleLE",8]),I.prototype.fieldSpec.push(["z","writeDoubleLE",8]),I.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),I.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),I.prototype.fieldSpec.push(["flags","writeUInt8",1]);var v=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_GNSS",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_GNSS",v.prototype.msg_type=554,v.prototype.constructor=v,v.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"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),v.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),v.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),v.prototype.fieldSpec.push(["height","writeDoubleLE",8]),v.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),v.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),v.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),v.prototype.fieldSpec.push(["flags","writeUInt8",1]);var L=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_ECEF_GNSS",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_ECEF_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_NED_GNSS",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_NED_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_BODY",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_COG",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_AGE_CORRECTIONS",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_GPS_TIME_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_DOPS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_POS_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_POS_LLH_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BASELINE_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BASELINE_NED_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_NED_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BASELINE_HEADING_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(B.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_PROTECTION_LEVEL_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_PROTECTION_LEVEL",this.fields=t||this.parser.parse(e.payload),this};(z.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ITRF",this.fields=t||this.parser.parse(e.payload),this};(H.prototype=Object.create(r.prototype)).messageType="MSG_ITRF",H.prototype.msg_type=580,H.prototype.constructor=H,H.prototype.parser=(new o).endianess("little").uint8("ssr_iod").uint8("sn_counter_n").string("sn",{length:31}).uint8("tn_counter_m").string("tn",{length:31}).uint8("sin").uint16("utn").uint16("re_t0").int32("delta_X0").int32("delta_Y0").int32("delta_Z0").int32("theta_01").int32("theta_02").int32("theta_03").int32("scale").int32("dot_delta_X0").int32("dot_delta_Y0").int32("dot_delta_Z0").int32("dot_theta_01").int32("dot_theta_02").int32("dot_theta_03").int16("dot_scale"),H.prototype.fieldSpec=[],H.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),H.prototype.fieldSpec.push(["sn_counter_n","writeUInt8",1]),H.prototype.fieldSpec.push(["sn","string",31]),H.prototype.fieldSpec.push(["tn_counter_m","writeUInt8",1]),H.prototype.fieldSpec.push(["tn","string",31]),H.prototype.fieldSpec.push(["sin","writeUInt8",1]),H.prototype.fieldSpec.push(["utn","writeUInt16LE",2]),H.prototype.fieldSpec.push(["re_t0","writeUInt16LE",2]),H.prototype.fieldSpec.push(["delta_X0","writeInt32LE",4]),H.prototype.fieldSpec.push(["delta_Y0","writeInt32LE",4]),H.prototype.fieldSpec.push(["delta_Z0","writeInt32LE",4]),H.prototype.fieldSpec.push(["theta_01","writeInt32LE",4]),H.prototype.fieldSpec.push(["theta_02","writeInt32LE",4]),H.prototype.fieldSpec.push(["theta_03","writeInt32LE",4]),H.prototype.fieldSpec.push(["scale","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_delta_X0","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_delta_Y0","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_delta_Z0","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_theta_01","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_theta_02","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_theta_03","writeInt32LE",4]),H.prototype.fieldSpec.push(["dot_scale","writeInt16LE",2]),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:I,MsgPosEcefCovGnss:I,554:v,MsgPosLlhGnss:v,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:k,MsgVelEcefDepA:k,517:F,MsgVelNedDepA:F,519:B,MsgBaselineHeadingDepA:B,534:q,MsgProtectionLevelDepA:q,535:z,MsgProtectionLevel:z,580:H,MsgItrf:H}},function(e,t,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=(p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec,p(0).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_NDB_EVENT",this.fields=t||this.parser.parse(e.payload),this});(s.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase),s=p(0).GnssSignal,n=p(0).GnssSignalDep,a=p(0).GPSTime,l=p(0).GPSTimeDep,c=p(0).GPSTimeSec,u=(p(0).SvId,function(e,t){return r.call(this,e),this.messageType="ObservationHeader",this.fields=t||this.parser.parse(e.payload),this});(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="Doppler",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="PackedObsContent",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="PackedOsrContent",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_OBS",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BASE_POS_LLH",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BASE_POS_ECEF",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.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 r.call(this,e),this.messageType="EphemerisCommonContent",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.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 r.call(this,e),this.messageType="EphemerisCommonContentDepB",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.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 r.call(this,e),this.messageType="EphemerisCommonContentDepA",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GPS_DEP_E",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GPS_DEP_F",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.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 I=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GPS",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GPS",I.prototype.msg_type=138,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 v=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_QZSS",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_QZSS",v.prototype.msg_type=142,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 r.call(this,e),this.messageType="MSG_EPHEMERIS_BDS",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GAL_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GAL",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_D",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_D",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(r.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 r.call(this,e),this.messageType="ObservationHeaderDep",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(r.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 r.call(this,e),this.messageType="CarrierPhaseDepA",this.fields=t||this.parser.parse(e.payload),this};(B.prototype=Object.create(r.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 r.call(this,e),this.messageType="PackedObsContentDepA",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(r.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 r.call(this,e),this.messageType="PackedObsContentDepB",this.fields=t||this.parser.parse(e.payload),this};(z.prototype=Object.create(r.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 r.call(this,e),this.messageType="PackedObsContentDepC",this.fields=t||this.parser.parse(e.payload),this};(H.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_OBS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(V.prototype=Object.create(r.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:F.prototype.parser}).array("obs",{type:q.prototype.parser,readUntil:"eof"}),V.prototype.fieldSpec=[],V.prototype.fieldSpec.push(["header",F.prototype.fieldSpec]),V.prototype.fieldSpec.push(["obs","array",q.prototype.fieldSpec,function(){return this.fields.array.length},null]);var Y=function(e,t){return r.call(this,e),this.messageType="MSG_OBS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(Y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_OBS_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(W.prototype=Object.create(r.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:H.prototype.parser,readUntil:"eof"}),W.prototype.fieldSpec=[],W.prototype.fieldSpec.push(["header",F.prototype.fieldSpec]),W.prototype.fieldSpec.push(["obs","array",H.prototype.fieldSpec,function(){return this.fields.array.length},null]);var Q=function(e,t){return r.call(this,e),this.messageType="MSG_IONO",this.fields=t||this.parser.parse(e.payload),this};(Q.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SV_CONFIGURATION_GPS_DEP",this.fields=t||this.parser.parse(e.payload),this};(K.prototype=Object.create(r.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 r.call(this,e),this.messageType="GnssCapb",this.fields=t||this.parser.parse(e.payload),this};(X.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_GNSS_CAPB",this.fields=t||this.parser.parse(e.payload),this};(J.prototype=Object.create(r.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 Z=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(Z.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_DELAY_DEP_A",Z.prototype.msg_type=146,Z.prototype.constructor=Z,Z.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"),Z.prototype.fieldSpec=[],Z.prototype.fieldSpec.push(["t_op",l.prototype.fieldSpec]),Z.prototype.fieldSpec.push(["prn","writeUInt8",1]),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 $=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_B",this.fields=t||this.parser.parse(e.payload),this};($.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_DELAY_DEP_B",$.prototype.msg_type=147,$.prototype.constructor=$,$.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"),$.prototype.fieldSpec=[],$.prototype.fieldSpec.push(["t_op",c.prototype.fieldSpec]),$.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),$.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 ee=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY",this.fields=t||this.parser.parse(e.payload),this};(ee.prototype=Object.create(r.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 r.call(this,e),this.messageType="AlmanacCommonContent",this.fields=t||this.parser.parse(e.payload),this};(te.prototype=Object.create(r.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 pe=function(e,t){return r.call(this,e),this.messageType="AlmanacCommonContentDep",this.fields=t||this.parser.parse(e.payload),this};(pe.prototype=Object.create(r.prototype)).messageType="AlmanacCommonContentDep",pe.prototype.constructor=pe,pe.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"),pe.prototype.fieldSpec=[],pe.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),pe.prototype.fieldSpec.push(["toa",c.prototype.fieldSpec]),pe.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),pe.prototype.fieldSpec.push(["valid","writeUInt8",1]),pe.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);var re=function(e,t){return r.call(this,e),this.messageType="MSG_ALMANAC_GPS_DEP",this.fields=t||this.parser.parse(e.payload),this};(re.prototype=Object.create(r.prototype)).messageType="MSG_ALMANAC_GPS_DEP",re.prototype.msg_type=112,re.prototype.constructor=re,re.prototype.parser=(new o).endianess("little").nest("common",{type:pe.prototype.parser}).doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("af0").doublele("af1"),re.prototype.fieldSpec=[],re.prototype.fieldSpec.push(["common",pe.prototype.fieldSpec]),re.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),re.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),re.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),re.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),re.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),re.prototype.fieldSpec.push(["w","writeDoubleLE",8]),re.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),re.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),re.prototype.fieldSpec.push(["af1","writeDoubleLE",8]);var oe=function(e,t){return r.call(this,e),this.messageType="MSG_ALMANAC_GPS",this.fields=t||this.parser.parse(e.payload),this};(oe.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ALMANAC_GLO_DEP",this.fields=t||this.parser.parse(e.payload),this};(ie.prototype=Object.create(r.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:pe.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",pe.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 r.call(this,e),this.messageType="MSG_ALMANAC_GLO",this.fields=t||this.parser.parse(e.payload),this};(se.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_GLO_BIASES",this.fields=t||this.parser.parse(e.payload),this};(ne.prototype=Object.create(r.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 r.call(this,e),this.messageType="SvAzEl",this.fields=t||this.parser.parse(e.payload),this};(ae.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SV_AZ_EL",this.fields=t||this.parser.parse(e.payload),this};(le.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_OSR",this.fields=t||this.parser.parse(e.payload),this};(ce.prototype=Object.create(r.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:I,MsgEphemerisGps:I,142:v,MsgEphemerisQzss:v,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:k,MsgEphemerisDepC:k,ObservationHeaderDep:F,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:Z,MsgGroupDelayDepA:Z,147:$,MsgGroupDelayDepB:$,148:ee,MsgGroupDelay:ee,AlmanacCommonContent:te,AlmanacCommonContentDep:pe,112:re,MsgAlmanacGpsDep:re,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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_BASELINE_HEADING",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ORIENT_QUAT",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ORIENT_EULER",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ANGULAR_RATE",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=p(0).GnssSignalDep,n=p(0).GPSTime,a=p(0).GPSTimeDep,l=(p(0).GPSTimeSec,p(0).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_ALMANAC",this.fields=t||this.parser.parse(e.payload),this});(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SET_TIME",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_RESET",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_RESET_DEP",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_CW_RESULTS",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_CW_START",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_RESET_FILTERS",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_INIT_BASE_DEP",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_THREAD_STATE",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.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 r.call(this,e),this.messageType="UARTChannel",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.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 r.call(this,e),this.messageType="Period",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.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 r.call(this,e),this.messageType="Latency",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_UART_STATE",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_UART_STATE_DEPA",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.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 I=function(e,t){return r.call(this,e),this.messageType="MSG_IAR_STATE",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="MSG_IAR_STATE",I.prototype.msg_type=25,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").uint32("num_hyps"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["num_hyps","writeUInt32LE",4]);var v=function(e,t){return r.call(this,e),this.messageType="MSG_MASK_SATELLITE",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_MASK_SATELLITE",v.prototype.msg_type=43,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").uint8("mask").nest("sid",{type:i.prototype.parser}),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["mask","writeUInt8",1]),v.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]);var L=function(e,t){return r.call(this,e),this.messageType="MSG_MASK_SATELLITE_DEP",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_DEVICE_MONITOR",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_COMMAND_REQ",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_COMMAND_RESP",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_COMMAND_OUTPUT",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_NETWORK_STATE_REQ",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_NETWORK_STATE_RESP",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.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 r.call(this,e),this.messageType="NetworkUsage",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_NETWORK_BANDWIDTH_USAGE",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_CELL_MODEM_STATUS",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SPECAN_DEP",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SPECAN",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FRONT_END_GAIN",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.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:I,MsgIarState:I,43:v,MsgMaskSatellite:v,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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=(p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec,p(0).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_SBAS_RAW",this.fields=t||this.parser.parse(e.payload),this});(s.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_SAVE",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_WRITE",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_WRITE_RESP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_READ_REQ",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_REQ",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_RESP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_DONE",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_REGISTER",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_REGISTER_RESP",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="SolutionInputType",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SOLN_META_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SOLN_META",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="GNSSInputType",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="IMUInputType",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="OdoInputType",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=(p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec),n=p(0).SvId,a=function(e,t){return r.call(this,e),this.messageType="CodeBiasesContent",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="PhaseBiasesContent",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="STECHeader",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="GriddedCorrectionHeader",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="STECSatElement",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="TroposphericDelayCorrectionNoStd",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="TroposphericDelayCorrection",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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 r.call(this,e),this.messageType="STECResidualNoStd",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.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 r.call(this,e),this.messageType="STECResidual",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SSR_CODE_BIASES",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SSR_PHASE_BIASES",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SSR_STEC_CORRECTION_DEP",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.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 r.call(this,e),this.messageType="BoundsHeader",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.prototype)).messageType="BoundsHeader",m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("update_interval").uint8("sol_id"),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),m.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),m.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),m.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),m.prototype.fieldSpec.push(["sol_id","writeUInt8",1]);var b=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_STEC_CORRECTION",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.prototype)).messageType="MSG_SSR_STEC_CORRECTION",b.prototype.msg_type=1533,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod_atmo").uint16("tile_set_id").uint16("tile_id").uint8("n_sats").array("stec_sat_list",{type:y.prototype.parser,length:"n_sats"}),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),b.prototype.fieldSpec.push(["ssr_iod_atmo","writeUInt8",1]),b.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),b.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),b.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),b.prototype.fieldSpec.push(["stec_sat_list","array",y.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats"]);var I=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION",I.prototype.msg_type=1532,I.prototype.constructor=I,I.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"}),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["header",u.prototype.fieldSpec]),I.prototype.fieldSpec.push(["index","writeUInt16LE",2]),I.prototype.fieldSpec.push(["tropo_delay_correction",f.prototype.fieldSpec]),I.prototype.fieldSpec.push(["stec_residuals","array",_.prototype.fieldSpec,function(){return this.fields.array.length},null]);var v=function(e,t){return r.call(this,e),this.messageType="STECSatElementIntegrity",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="STECSatElementIntegrity",v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").nest("stec_residual",{type:_.prototype.parser}).uint8("stec_bound_mu").uint8("stec_bound_sig").uint8("stec_bound_mu_dot").uint8("stec_bound_sig_dot"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["stec_residual",_.prototype.fieldSpec]),v.prototype.fieldSpec.push(["stec_bound_mu","writeUInt8",1]),v.prototype.fieldSpec.push(["stec_bound_sig","writeUInt8",1]),v.prototype.fieldSpec.push(["stec_bound_mu_dot","writeUInt8",1]),v.prototype.fieldSpec.push(["stec_bound_sig_dot","writeUInt8",1]);var L=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION_BOUNDS",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_BOUNDS",L.prototype.msg_type=1534,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod_atmo").uint16("tile_set_id").uint16("tile_id").uint8("tropo_qi").uint16("grid_point_id").nest("tropo_delay_correction",{type:f.prototype.parser}).uint8("tropo_bound_mu").uint8("tropo_bound_sig").uint8("n_sats").array("stec_sat_list",{type:v.prototype.parser,length:"n_sats"}),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),L.prototype.fieldSpec.push(["ssr_iod_atmo","writeUInt8",1]),L.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),L.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),L.prototype.fieldSpec.push(["tropo_qi","writeUInt8",1]),L.prototype.fieldSpec.push(["grid_point_id","writeUInt16LE",2]),L.prototype.fieldSpec.push(["tropo_delay_correction",f.prototype.fieldSpec]),L.prototype.fieldSpec.push(["tropo_bound_mu","writeUInt8",1]),L.prototype.fieldSpec.push(["tropo_bound_sig","writeUInt8",1]),L.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),L.prototype.fieldSpec.push(["stec_sat_list","array",v.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats"]);var T=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_TILE_DEFINITION_DEP",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(r.prototype)).messageType="MSG_SSR_TILE_DEFINITION_DEP",T.prototype.msg_type=1526,T.prototype.constructor=T,T.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"),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),T.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),T.prototype.fieldSpec.push(["corner_nw_lat","writeInt16LE",2]),T.prototype.fieldSpec.push(["corner_nw_lon","writeInt16LE",2]),T.prototype.fieldSpec.push(["spacing_lat","writeUInt16LE",2]),T.prototype.fieldSpec.push(["spacing_lon","writeUInt16LE",2]),T.prototype.fieldSpec.push(["rows","writeUInt16LE",2]),T.prototype.fieldSpec.push(["cols","writeUInt16LE",2]),T.prototype.fieldSpec.push(["bitmask","writeUInt64LE",8]);var U=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_TILE_DEFINITION",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.prototype)).messageType="MSG_SSR_TILE_DEFINITION",U.prototype.msg_type=1527,U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").uint8("ssr_sol_id").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"),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["ssr_sol_id","writeUInt8",1]),U.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),U.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),U.prototype.fieldSpec.push(["corner_nw_lat","writeInt16LE",2]),U.prototype.fieldSpec.push(["corner_nw_lon","writeInt16LE",2]),U.prototype.fieldSpec.push(["spacing_lat","writeUInt16LE",2]),U.prototype.fieldSpec.push(["spacing_lon","writeUInt16LE",2]),U.prototype.fieldSpec.push(["rows","writeUInt16LE",2]),U.prototype.fieldSpec.push(["cols","writeUInt16LE",2]),U.prototype.fieldSpec.push(["bitmask","writeUInt64LE",8]);var M=function(e,t){return r.call(this,e),this.messageType="SatelliteAPC",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.prototype)).messageType="SatelliteAPC",M.prototype.constructor=M,M.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"}),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),M.prototype.fieldSpec.push(["sat_info","writeUInt8",1]),M.prototype.fieldSpec.push(["svn","writeUInt16LE",2]),M.prototype.fieldSpec.push(["pco","array","writeInt16LE",function(){return 2},3]),M.prototype.fieldSpec.push(["pcv","array","writeInt8",function(){return 1},21]);var D=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_SATELLITE_APC",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_SSR_SATELLITE_APC",D.prototype.msg_type=1540,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").array("apc",{type:M.prototype.parser,readUntil:"eof"}),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["apc","array",M.prototype.fieldSpec,function(){return this.fields.array.length},null]);var O=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_DEP_A",O.prototype.msg_type=1500,O.prototype.constructor=O,O.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"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),O.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),O.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),O.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),O.prototype.fieldSpec.push(["iod","writeUInt8",1]),O.prototype.fieldSpec.push(["radial","writeInt32LE",4]),O.prototype.fieldSpec.push(["along","writeInt32LE",4]),O.prototype.fieldSpec.push(["cross","writeInt32LE",4]),O.prototype.fieldSpec.push(["dot_radial","writeInt32LE",4]),O.prototype.fieldSpec.push(["dot_along","writeInt32LE",4]),O.prototype.fieldSpec.push(["dot_cross","writeInt32LE",4]),O.prototype.fieldSpec.push(["c0","writeInt32LE",4]),O.prototype.fieldSpec.push(["c1","writeInt32LE",4]),O.prototype.fieldSpec.push(["c2","writeInt32LE",4]);var G=function(e,t){return r.call(this,e),this.messageType="STECHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="STECHeaderDepA",G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("update_interval").uint8("iod_atmo"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),G.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),G.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),G.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),G.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]);var A=function(e,t){return r.call(this,e),this.messageType="GriddedCorrectionHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="GriddedCorrectionHeaderDepA",A.prototype.constructor=A,A.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"),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),A.prototype.fieldSpec.push(["num_msgs","writeUInt16LE",2]),A.prototype.fieldSpec.push(["seq_num","writeUInt16LE",2]),A.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),A.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]),A.prototype.fieldSpec.push(["tropo_quality_indicator","writeUInt8",1]);var C=function(e,t){return r.call(this,e),this.messageType="GridDefinitionHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.prototype)).messageType="GridDefinitionHeaderDepA",C.prototype.constructor=C,C.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"),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["region_size_inverse","writeUInt8",1]),C.prototype.fieldSpec.push(["area_width","writeUInt16LE",2]),C.prototype.fieldSpec.push(["lat_nw_corner_enc","writeUInt16LE",2]),C.prototype.fieldSpec.push(["lon_nw_corner_enc","writeUInt16LE",2]),C.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),C.prototype.fieldSpec.push(["seq_num","writeUInt8",1]);var R=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_STEC_CORRECTION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.prototype)).messageType="MSG_SSR_STEC_CORRECTION_DEP_A",R.prototype.msg_type=1515,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").nest("header",{type:G.prototype.parser}).array("stec_sat_list",{type:y.prototype.parser,readUntil:"eof"}),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["header",G.prototype.fieldSpec]),R.prototype.fieldSpec.push(["stec_sat_list","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);var P=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A",P.prototype.msg_type=1520,P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").nest("header",{type:A.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:h.prototype.parser}).array("stec_residuals",{type:d.prototype.parser,readUntil:"eof"}),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["header",A.prototype.fieldSpec]),P.prototype.fieldSpec.push(["index","writeUInt16LE",2]),P.prototype.fieldSpec.push(["tropo_delay_correction",h.prototype.fieldSpec]),P.prototype.fieldSpec.push(["stec_residuals","array",d.prototype.fieldSpec,function(){return this.fields.array.length},null]);var N=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_DEP_A",N.prototype.msg_type=1530,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").nest("header",{type:A.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:f.prototype.parser}).array("stec_residuals",{type:_.prototype.parser,readUntil:"eof"}),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["header",A.prototype.fieldSpec]),N.prototype.fieldSpec.push(["index","writeUInt16LE",2]),N.prototype.fieldSpec.push(["tropo_delay_correction",f.prototype.fieldSpec]),N.prototype.fieldSpec.push(["stec_residuals","array",_.prototype.fieldSpec,function(){return this.fields.array.length},null]);var j=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRID_DEFINITION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRID_DEFINITION_DEP_A",j.prototype.msg_type=1525,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").nest("header",{type:C.prototype.parser}).array("rle_list",{type:"uint8",readUntil:"eof"}),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["header",C.prototype.fieldSpec]),j.prototype.fieldSpec.push(["rle_list","array","writeUInt8",function(){return 1},null]);var x=function(e,t){return r.call(this,e),this.messageType="OrbitClockBound",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(r.prototype)).messageType="OrbitClockBound",x.prototype.constructor=x,x.prototype.parser=(new o).endianess("little").uint8("sat_id").uint8("orb_radial_bound_mu").uint8("orb_along_bound_mu").uint8("orb_cross_bound_mu").uint8("orb_radial_bound_sig").uint8("orb_along_bound_sig").uint8("orb_cross_bound_sig").uint8("clock_bound_mu").uint8("clock_bound_sig"),x.prototype.fieldSpec=[],x.prototype.fieldSpec.push(["sat_id","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_radial_bound_mu","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_along_bound_mu","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_cross_bound_mu","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_radial_bound_sig","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_along_bound_sig","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_cross_bound_sig","writeUInt8",1]),x.prototype.fieldSpec.push(["clock_bound_mu","writeUInt8",1]),x.prototype.fieldSpec.push(["clock_bound_sig","writeUInt8",1]);var k=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS",k.prototype.msg_type=1502,k.prototype.constructor=k,k.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod").uint8("const_id").uint8("n_sats").array("orbit_clock_bounds",{type:x.prototype.parser,length:"n_sats"}),k.prototype.fieldSpec=[],k.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),k.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),k.prototype.fieldSpec.push(["const_id","writeUInt8",1]),k.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),k.prototype.fieldSpec.push(["orbit_clock_bounds","array",x.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats"]);var F=function(e,t){return r.call(this,e),this.messageType="CodePhaseBiasesSatSig",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(r.prototype)).messageType="CodePhaseBiasesSatSig",F.prototype.constructor=F,F.prototype.parser=(new o).endianess("little").uint8("sat_id").uint8("signal_id").uint8("code_bias_bound_mu").uint8("code_bias_bound_sig").uint8("phase_bias_bound_mu").uint8("phase_bias_bound_sig"),F.prototype.fieldSpec=[],F.prototype.fieldSpec.push(["sat_id","writeUInt8",1]),F.prototype.fieldSpec.push(["signal_id","writeUInt8",1]),F.prototype.fieldSpec.push(["code_bias_bound_mu","writeUInt8",1]),F.prototype.fieldSpec.push(["code_bias_bound_sig","writeUInt8",1]),F.prototype.fieldSpec.push(["phase_bias_bound_mu","writeUInt8",1]),F.prototype.fieldSpec.push(["phase_bias_bound_sig","writeUInt8",1]);var B=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_CODE_PHASE_BIASES_BOUNDS",this.fields=t||this.parser.parse(e.payload),this};(B.prototype=Object.create(r.prototype)).messageType="MSG_SSR_CODE_PHASE_BIASES_BOUNDS",B.prototype.msg_type=1516,B.prototype.constructor=B,B.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod").uint8("const_id").uint8("n_sats_signals").array("satellites_signals",{type:F.prototype.parser,length:"n_sats_signals"}),B.prototype.fieldSpec=[],B.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),B.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),B.prototype.fieldSpec.push(["const_id","writeUInt8",1]),B.prototype.fieldSpec.push(["n_sats_signals","writeUInt8",1]),B.prototype.fieldSpec.push(["satellites_signals","array",F.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats_signals"]);var q=function(e,t){return r.call(this,e),this.messageType="OrbitClockBoundDegradation",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(r.prototype)).messageType="OrbitClockBoundDegradation",q.prototype.constructor=q,q.prototype.parser=(new o).endianess("little").uint8("orb_radial_bound_mu_dot").uint8("orb_along_bound_mu_dot").uint8("orb_cross_bound_mu_dot").uint8("orb_radial_bound_sig_dot").uint8("orb_along_bound_sig_dot").uint8("orb_cross_bound_sig_dot").uint8("clock_bound_mu_dot").uint8("clock_bound_sig_dot"),q.prototype.fieldSpec=[],q.prototype.fieldSpec.push(["orb_radial_bound_mu_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_along_bound_mu_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_cross_bound_mu_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_radial_bound_sig_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_along_bound_sig_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_cross_bound_sig_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["clock_bound_mu_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["clock_bound_sig_dot","writeUInt8",1]);var z=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION",this.fields=t||this.parser.parse(e.payload),this};(z.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION",z.prototype.msg_type=1503,z.prototype.constructor=z,z.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod").uint8("const_id").uint64("sat_bitmask").nest("orbit_clock_bounds_degradation",{type:q.prototype.parser}),z.prototype.fieldSpec=[],z.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),z.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),z.prototype.fieldSpec.push(["const_id","writeUInt8",1]),z.prototype.fieldSpec.push(["sat_bitmask","writeUInt64LE",8]),z.prototype.fieldSpec.push(["orbit_clock_bounds_degradation",q.prototype.fieldSpec]),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,BoundsHeader:m,1533:b,MsgSsrStecCorrection:b,1532:I,MsgSsrGriddedCorrection:I,STECSatElementIntegrity:v,1534:L,MsgSsrGriddedCorrectionBounds:L,1526:T,MsgSsrTileDefinitionDep:T,1527:U,MsgSsrTileDefinition:U,SatelliteAPC:M,1540:D,MsgSsrSatelliteApc:D,1500:O,MsgSsrOrbitClockDepA:O,STECHeaderDepA:G,GriddedCorrectionHeaderDepA:A,GridDefinitionHeaderDepA:C,1515:R,MsgSsrStecCorrectionDepA:R,1520:P,MsgSsrGriddedCorrectionNoStdDepA:P,1530:N,MsgSsrGriddedCorrectionDepA:N,1525:j,MsgSsrGridDefinitionDepA:j,OrbitClockBound:x,1502:k,MsgSsrOrbitClockBounds:k,CodePhaseBiasesSatSig:F,1516:B,MsgSsrCodePhaseBiasesBounds:B,OrbitClockBoundDegradation:q,1503:z,MsgSsrOrbitClockBoundsDegradation:z}},function(e,t,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_STARTUP",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_DGNSS_STATUS",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_HEARTBEAT",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="SubSystemReport",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_STATUS_REPORT",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="StatusJournalItem",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_STATUS_JOURNAL",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_INS_STATUS",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_CSAC_TELEMETRY",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_CSAC_TELEMETRY_LABELS",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_INS_UPDATES",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_GNSS_TIME_OFFSET",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_PPS_TIME",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SENSOR_AID_EVENT",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_GROUP_META",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase),s=p(0).GnssSignal,n=p(0).GnssSignalDep,a=p(0).GPSTime,l=p(0).GPSTimeDep,c=(p(0).GPSTimeSec,p(0).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_STATE_DETAILED_DEP_A",this.fields=t||this.parser.parse(e.payload),this});(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_TRACKING_STATE_DETAILED_DEP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="TrackingChannelState",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_TRACKING_STATE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="MeasurementState",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_MEASUREMENT_STATE",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.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 r.call(this,e),this.messageType="TrackingChannelCorrelation",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_TRACKING_IQ",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.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 r.call(this,e),this.messageType="TrackingChannelCorrelationDep",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_TRACKING_IQ_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_TRACKING_IQ_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.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 r.call(this,e),this.messageType="TrackingChannelStateDepA",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_TRACKING_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.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 I=function(e,t){return r.call(this,e),this.messageType="TrackingChannelStateDepB",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="TrackingChannelStateDepB",I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").uint8("state").nest("sid",{type:n.prototype.parser}).floatle("cn0"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["state","writeUInt8",1]),I.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),I.prototype.fieldSpec.push(["cn0","writeFloatLE",4]);var v=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_STATE_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_STATE_DEP_B",v.prototype.msg_type=19,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").array("states",{type:I.prototype.parser,readUntil:"eof"}),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["states","array",I.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:I,19:v,MsgTrackingStateDepB:v}},function(e,t,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_USER_DATA",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_ODOMETRY",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_WHEELTICK",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r(e,t){if(e===t)return 0;for(var p=e.length,r=t.length,o=0,i=Math.min(p,r);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],p,r))return!1;return!0}(e,t,p,s))}return p?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,p,r){var o;if("function"!=typeof t)throw new TypeError('"block" argument must be a function');"string"==typeof p&&(r=p,p=null),o=function(e){var t;try{e()}catch(e){t=e}return t}(t),r=(p&&p.name?" ("+p.name+").":".")+(r?" "+r:"."),e&&!o&&_(o,p,"Missing expected exception"+r);var s="string"==typeof r,n=!e&&o&&!p;if((!e&&i.isError(o)&&s&&E(o,p)||n)&&_(o,p,"Got unwanted exception"+r),e&&o&&p&&!E(o,p)||!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 p=new Error;if(p.stack){var r=p.stack,o=h(t),i=r.indexOf("\n"+o);if(i>=0){var s=r.indexOf("\n",i+1);r=r.substring(s+1)}this.stack=r}}},i.inherits(u.AssertionError,Error),u.fail=_,u.ok=S,u.equal=function(e,t,p){e!=t&&_(e,t,p,"==",u.equal)},u.notEqual=function(e,t,p){e==t&&_(e,t,p,"!=",u.notEqual)},u.deepEqual=function(e,t,p){g(e,t,!1)||_(e,t,p,"deepEqual",u.deepEqual)},u.deepStrictEqual=function(e,t,p){g(e,t,!0)||_(e,t,p,"deepStrictEqual",u.deepStrictEqual)},u.notDeepEqual=function(e,t,p){g(e,t,!1)&&_(e,t,p,"notDeepEqual",u.notDeepEqual)},u.notDeepStrictEqual=function e(t,p,r){g(t,p,!0)&&_(t,p,r,"notDeepStrictEqual",e)},u.strictEqual=function(e,t,p){e!==t&&_(e,t,p,"===",u.strictEqual)},u.notStrictEqual=function(e,t,p){e===t&&_(e,t,p,"!==",u.notStrictEqual)},u.throws=function(e,t,p){m(!0,e,t,p)},u.doesNotThrow=function(e,t,p){m(!1,e,t,p)},u.ifError=function(e){if(e)throw e};var b=Object.keys||function(e){var t=[];for(var p in e)s.call(e,p)&&t.push(p);return t}}).call(this,p(5))},function(e,t,p){var r;!function(p){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 p=parseInt(e,t||10);return this._low=65535&p,this._high=p>>>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,p=t>>>16;return p+=this._high+e._high,this._low=65535&t,this._high=65535&p,this},o.prototype.subtract=function(e){return this.add(e.clone().negate())},o.prototype.multiply=function(e){var t,p,r=this._high,o=this._low,i=e._high,s=e._low;return t=(p=o*s)>>>16,t+=r*s,t&=65535,t+=o*i,this._low=65535&p,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(),p=-1;!this.lt(t);)t.shiftLeft(1,!0),p++;for(this.remainder=this.clone(),this._low=0,this._high=0;p>=0;p--)t.shiftRight(1),this.remainder.lt(t)||(this.remainder.subtract(t),p>=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===(r=function(){return o}.apply(t,[]))||(e.exports=r)}()},function(e,t,p){var r;!function(p){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,p,r){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,p,r)}function n(e,t,p,r){return void 0===p?(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|p,this._a48=0|r,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 p=o[t]||new s(Math.pow(t,5)),r=0,i=e.length;r=0&&(p.div(t),r[o]=p.remainder.toNumber().toString(e),p.gt(t));o--);return r[o-1]=p.toNumber().toString(e),r.join("")},s.prototype.add=function(e){var t=this._a00+e._a00,p=t>>>16,r=(p+=this._a16+e._a16)>>>16,o=(r+=this._a32+e._a32)>>>16;return o+=this._a48+e._a48,this._a00=65535&t,this._a16=65535&p,this._a32=65535&r,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,p=this._a16,r=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+=p*i)>>>16;var u=(c+=t*n)>>>16;return c&=65535,u+=(c+=p*s)>>>16,c&=65535,u+=(c+=r*i)>>>16,u+=t*e._a48,u&=65535,u+=p*n,u&=65535,u+=r*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(),p=-1;!this.lt(t);)t.shiftLeft(1,!0),p++;for(this.remainder=this.clone(),this._a00=0,this._a16=0,this._a32=0,this._a48=0;p>=0;p--)t.shiftRight(1),this.remainder.lt(t)||(this.remainder.subtract(t),p>=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 p=this._a48<<16|this._a32,r=this._a16<<16|this._a00,o=p<>>32-e,i=r<>>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 p=this._a48<<16|this._a32,r=this._a16<<16|this._a00,o=p>>>e|r<<32-e,i=r>>>e|p<<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===(r=function(){return s}.apply(t,[]))||(e.exports=r)}()},function(e,t,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=p(0).GnssSignalDep,n=(p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec,p(0).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_ACQ_RESULT",this.fields=t||this.parser.parse(e.payload),this});(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ACQ_RESULT_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="AcqSvProfile",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="AcqSvProfileDep",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ACQ_SV_PROFILE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ACQ_SV_PROFILE_DEP",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_REQ",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_RESP",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BOOTLOADER_JUMP_TO_APP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_NAP_DEVICE_DNA_REQ",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_NAP_DEVICE_DNA_RESP",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BOOTLOADER_HANDSHAKE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_EXT_EVENT",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_FILEIO_READ_REQ",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FILEIO_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FILEIO_READ_DIR_REQ",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FILEIO_READ_DIR_RESP",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FILEIO_REMOVE",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FILEIO_WRITE_REQ",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FILEIO_WRITE_RESP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FILEIO_CONFIG_REQ",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FILEIO_CONFIG_RESP",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_FLASH_PROGRAM",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FLASH_DONE",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FLASH_READ_REQ",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FLASH_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FLASH_ERASE",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_STM_FLASH_LOCK_SECTOR",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_STM_FLASH_UNLOCK_SECTOR",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_STM_UNIQUE_ID_REQ",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_STM_UNIQUE_ID_RESP",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_M25_FLASH_WRITE_STATUS",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_IMU_RAW",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_IMU_AUX",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal,p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec),s=p(0).SvId,n=function(e,t){return r.call(this,e),this.messageType="IntegritySSRHeader",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.prototype)).messageType="IntegritySSRHeader",n.prototype.constructor=n,n.prototype.parser=(new o).endianess("little").nest("obs_time",{type:i.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("ssr_sol_id").uint16("tile_set_id").uint16("tile_id").uint8("chain_id"),n.prototype.fieldSpec=[],n.prototype.fieldSpec.push(["obs_time",i.prototype.fieldSpec]),n.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),n.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),n.prototype.fieldSpec.push(["ssr_sol_id","writeUInt8",1]),n.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),n.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),n.prototype.fieldSpec.push(["chain_id","writeUInt8",1]);var a=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_HIGH_LEVEL",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_HIGH_LEVEL",a.prototype.msg_type=3001,a.prototype.constructor=a,a.prototype.parser=(new o).endianess("little").nest("obs_time",{type:i.prototype.parser}).nest("corr_time",{type:i.prototype.parser}).uint8("ssr_sol_id").uint16("tile_set_id").uint16("tile_id").uint8("chain_id").uint8("use_gps_sat").uint8("use_gal_sat").uint8("use_bds_sat").array("reserved",{length:6,type:"uint8"}).uint8("use_tropo_grid_points").uint8("use_iono_grid_points").uint8("use_iono_tile_sat_los").uint8("use_iono_grid_point_sat_los"),a.prototype.fieldSpec=[],a.prototype.fieldSpec.push(["obs_time",i.prototype.fieldSpec]),a.prototype.fieldSpec.push(["corr_time",i.prototype.fieldSpec]),a.prototype.fieldSpec.push(["ssr_sol_id","writeUInt8",1]),a.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),a.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),a.prototype.fieldSpec.push(["chain_id","writeUInt8",1]),a.prototype.fieldSpec.push(["use_gps_sat","writeUInt8",1]),a.prototype.fieldSpec.push(["use_gal_sat","writeUInt8",1]),a.prototype.fieldSpec.push(["use_bds_sat","writeUInt8",1]),a.prototype.fieldSpec.push(["reserved","array","writeUInt8",function(){return 1},6]),a.prototype.fieldSpec.push(["use_tropo_grid_points","writeUInt8",1]),a.prototype.fieldSpec.push(["use_iono_grid_points","writeUInt8",1]),a.prototype.fieldSpec.push(["use_iono_tile_sat_los","writeUInt8",1]),a.prototype.fieldSpec.push(["use_iono_grid_point_sat_los","writeUInt8",1]);var l=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_SATELLITES",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_SATELLITES",l.prototype.msg_type=3005,l.prototype.constructor=l,l.prototype.parser=(new o).endianess("little").nest("obs_time",{type:i.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("ssr_sol_id").uint8("chain_id").uint8("const_id").uint8("n_faulty_sats").array("faulty_sats",{type:"uint8",length:"n_faulty_sats"}),l.prototype.fieldSpec=[],l.prototype.fieldSpec.push(["obs_time",i.prototype.fieldSpec]),l.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),l.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),l.prototype.fieldSpec.push(["ssr_sol_id","writeUInt8",1]),l.prototype.fieldSpec.push(["chain_id","writeUInt8",1]),l.prototype.fieldSpec.push(["const_id","writeUInt8",1]),l.prototype.fieldSpec.push(["n_faulty_sats","writeUInt8",1]),l.prototype.fieldSpec.push(["faulty_sats","array","writeUInt8",function(){return 1},"n_faulty_sats"]);var c=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_TROPO_GRID_POINTS",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_TROPO_GRID_POINTS",c.prototype.msg_type=3011,c.prototype.constructor=c,c.prototype.parser=(new o).endianess("little").nest("header",{type:n.prototype.parser}).uint8("n_faulty_points").array("faulty_points",{type:"uint16le",length:"n_faulty_points"}),c.prototype.fieldSpec=[],c.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),c.prototype.fieldSpec.push(["n_faulty_points","writeUInt8",1]),c.prototype.fieldSpec.push(["faulty_points","array","writeUInt16LE",function(){return 2},"n_faulty_points"]);var u=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_IONO_GRID_POINTS",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_IONO_GRID_POINTS",u.prototype.msg_type=3015,u.prototype.constructor=u,u.prototype.parser=(new o).endianess("little").nest("header",{type:n.prototype.parser}).uint8("n_faulty_points").array("faulty_points",{type:"uint16le",length:"n_faulty_points"}),u.prototype.fieldSpec=[],u.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),u.prototype.fieldSpec.push(["n_faulty_points","writeUInt8",1]),u.prototype.fieldSpec.push(["faulty_points","array","writeUInt16LE",function(){return 2},"n_faulty_points"]);var y=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_IONO_TILE_SAT_LOS",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_IONO_TILE_SAT_LOS",y.prototype.msg_type=3021,y.prototype.constructor=y,y.prototype.parser=(new o).endianess("little").nest("header",{type:n.prototype.parser}).uint8("n_faulty_los").array("faulty_los",{type:s.prototype.parser,length:"n_faulty_los"}),y.prototype.fieldSpec=[],y.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),y.prototype.fieldSpec.push(["n_faulty_los","writeUInt8",1]),y.prototype.fieldSpec.push(["faulty_los","array",s.prototype.fieldSpec,function(){return this.fields.array.length},"n_faulty_los"]);var h=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.prototype)).messageType="MSG_SSR_FLAG_IONO_GRID_POINT_SAT_LOS",h.prototype.msg_type=3025,h.prototype.constructor=h,h.prototype.parser=(new o).endianess("little").nest("header",{type:n.prototype.parser}).uint16("grid_point_id").uint8("n_faulty_los").array("faulty_los",{type:s.prototype.parser,length:"n_faulty_los"}),h.prototype.fieldSpec=[],h.prototype.fieldSpec.push(["header",n.prototype.fieldSpec]),h.prototype.fieldSpec.push(["grid_point_id","writeUInt16LE",2]),h.prototype.fieldSpec.push(["n_faulty_los","writeUInt8",1]),h.prototype.fieldSpec.push(["faulty_los","array",s.prototype.fieldSpec,function(){return this.fields.array.length},"n_faulty_los"]),e.exports={IntegritySSRHeader:n,3001:a,MsgSsrFlagHighLevel:a,3005:l,MsgSsrFlagSatellites:l,3011:c,MsgSsrFlagTropoGridPoints:c,3015:u,MsgSsrFlagIonoGridPoints:u,3021:y,MsgSsrFlagIonoTileSatLos:y,3025:h,MsgSsrFlagIonoGridPointSatLos:h}},function(e,t,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_LINUX_CPU_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_MEM_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_SYS_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_PROCESS_SOCKET_COUNTS",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_PROCESS_SOCKET_QUEUES",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_SOCKET_USAGE",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_PROCESS_FD_COUNT",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_PROCESS_FD_SUMMARY",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_CPU_STATE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_MEM_STATE",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_LINUX_SYS_STATE",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_LOG",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FWD",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_PRINT_DEP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_MAG_RAW",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_GPS_TIME",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_GPS_TIME_GNSS",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_UTC_TIME",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_UTC_TIME_GNSS",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_DOPS",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_POS_ECEF",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_POS_ECEF_COV",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_POS_LLH",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_POS_LLH_COV",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="EstimatedHorizontalErrorEllipse",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_POS_LLH_ACC",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BASELINE_ECEF",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BASELINE_NED",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_ECEF",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_ECEF_COV",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_NED",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_NED_COV",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_POS_ECEF_GNSS",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.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 I=function(e,t){return r.call(this,e),this.messageType="MSG_POS_ECEF_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="MSG_POS_ECEF_COV_GNSS",I.prototype.msg_type=564,I.prototype.constructor=I,I.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"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),I.prototype.fieldSpec.push(["x","writeDoubleLE",8]),I.prototype.fieldSpec.push(["y","writeDoubleLE",8]),I.prototype.fieldSpec.push(["z","writeDoubleLE",8]),I.prototype.fieldSpec.push(["cov_x_x","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_x_y","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_x_z","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_y_y","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_y_z","writeFloatLE",4]),I.prototype.fieldSpec.push(["cov_z_z","writeFloatLE",4]),I.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),I.prototype.fieldSpec.push(["flags","writeUInt8",1]);var v=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_GNSS",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_POS_LLH_GNSS",v.prototype.msg_type=554,v.prototype.constructor=v,v.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"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["tow","writeUInt32LE",4]),v.prototype.fieldSpec.push(["lat","writeDoubleLE",8]),v.prototype.fieldSpec.push(["lon","writeDoubleLE",8]),v.prototype.fieldSpec.push(["height","writeDoubleLE",8]),v.prototype.fieldSpec.push(["h_accuracy","writeUInt16LE",2]),v.prototype.fieldSpec.push(["v_accuracy","writeUInt16LE",2]),v.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),v.prototype.fieldSpec.push(["flags","writeUInt8",1]);var L=function(e,t){return r.call(this,e),this.messageType="MSG_POS_LLH_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_ECEF_GNSS",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_ECEF_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_NED_GNSS",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_NED_COV_GNSS",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_BODY",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_COG",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_AGE_CORRECTIONS",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_GPS_TIME_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_DOPS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_POS_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_POS_LLH_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BASELINE_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BASELINE_NED_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_ECEF_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_VEL_NED_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BASELINE_HEADING_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(B.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_PROTECTION_LEVEL_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_PROTECTION_LEVEL",this.fields=t||this.parser.parse(e.payload),this};(z.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_GPS_LEAP_SECOND",this.fields=t||this.parser.parse(e.payload),this};(H.prototype=Object.create(r.prototype)).messageType="MSG_GPS_LEAP_SECOND",H.prototype.msg_type=570,H.prototype.constructor=H,H.prototype.parser=(new o).endianess("little").int16("bias_coeff").int16("drift_coeff").int8("drift_rate_coeff").int8("count_before").uint16("tow_s").uint16("wn").uint16("ref_wn").uint8("ref_dn").int8("count_after"),H.prototype.fieldSpec=[],H.prototype.fieldSpec.push(["bias_coeff","writeInt16LE",2]),H.prototype.fieldSpec.push(["drift_coeff","writeInt16LE",2]),H.prototype.fieldSpec.push(["drift_rate_coeff","writeInt8",1]),H.prototype.fieldSpec.push(["count_before","writeInt8",1]),H.prototype.fieldSpec.push(["tow_s","writeUInt16LE",2]),H.prototype.fieldSpec.push(["wn","writeUInt16LE",2]),H.prototype.fieldSpec.push(["ref_wn","writeUInt16LE",2]),H.prototype.fieldSpec.push(["ref_dn","writeUInt8",1]),H.prototype.fieldSpec.push(["count_after","writeInt8",1]);var V=function(e,t){return r.call(this,e),this.messageType="MSG_ITRF",this.fields=t||this.parser.parse(e.payload),this};(V.prototype=Object.create(r.prototype)).messageType="MSG_ITRF",V.prototype.msg_type=580,V.prototype.constructor=V,V.prototype.parser=(new o).endianess("little").uint8("ssr_iod").uint8("sn_counter_n").string("sn",{length:31}).uint8("tn_counter_m").string("tn",{length:31}).uint8("sin").uint16("utn").uint16("re_t0").int32("delta_X0").int32("delta_Y0").int32("delta_Z0").int32("theta_01").int32("theta_02").int32("theta_03").int32("scale").int32("dot_delta_X0").int32("dot_delta_Y0").int32("dot_delta_Z0").int32("dot_theta_01").int32("dot_theta_02").int32("dot_theta_03").int16("dot_scale"),V.prototype.fieldSpec=[],V.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),V.prototype.fieldSpec.push(["sn_counter_n","writeUInt8",1]),V.prototype.fieldSpec.push(["sn","string",31]),V.prototype.fieldSpec.push(["tn_counter_m","writeUInt8",1]),V.prototype.fieldSpec.push(["tn","string",31]),V.prototype.fieldSpec.push(["sin","writeUInt8",1]),V.prototype.fieldSpec.push(["utn","writeUInt16LE",2]),V.prototype.fieldSpec.push(["re_t0","writeUInt16LE",2]),V.prototype.fieldSpec.push(["delta_X0","writeInt32LE",4]),V.prototype.fieldSpec.push(["delta_Y0","writeInt32LE",4]),V.prototype.fieldSpec.push(["delta_Z0","writeInt32LE",4]),V.prototype.fieldSpec.push(["theta_01","writeInt32LE",4]),V.prototype.fieldSpec.push(["theta_02","writeInt32LE",4]),V.prototype.fieldSpec.push(["theta_03","writeInt32LE",4]),V.prototype.fieldSpec.push(["scale","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_delta_X0","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_delta_Y0","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_delta_Z0","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_theta_01","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_theta_02","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_theta_03","writeInt32LE",4]),V.prototype.fieldSpec.push(["dot_scale","writeInt16LE",2]),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:I,MsgPosEcefCovGnss:I,554:v,MsgPosLlhGnss:v,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:k,MsgVelEcefDepA:k,517:F,MsgVelNedDepA:F,519:B,MsgBaselineHeadingDepA:B,534:q,MsgProtectionLevelDepA:q,535:z,MsgProtectionLevel:z,570:H,MsgGpsLeapSecond:H,580:V,MsgItrf:V}},function(e,t,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=(p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec,p(0).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_NDB_EVENT",this.fields=t||this.parser.parse(e.payload),this});(s.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase),s=p(0).GnssSignal,n=p(0).GnssSignalDep,a=p(0).GPSTime,l=p(0).GPSTimeDep,c=p(0).GPSTimeSec,u=(p(0).SvId,function(e,t){return r.call(this,e),this.messageType="ObservationHeader",this.fields=t||this.parser.parse(e.payload),this});(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="Doppler",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="PackedObsContent",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="PackedOsrContent",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_OBS",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BASE_POS_LLH",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_BASE_POS_ECEF",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.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 r.call(this,e),this.messageType="EphemerisCommonContent",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.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 r.call(this,e),this.messageType="EphemerisCommonContentDepB",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.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 r.call(this,e),this.messageType="EphemerisCommonContentDepA",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GPS_DEP_E",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GPS_DEP_F",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.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 I=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_GPS",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_GPS",I.prototype.msg_type=138,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 v=function(e,t){return r.call(this,e),this.messageType="MSG_EPHEMERIS_QZSS",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_EPHEMERIS_QZSS",v.prototype.msg_type=142,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 r.call(this,e),this.messageType="MSG_EPHEMERIS_BDS",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GAL_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GAL",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_SBAS",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO_DEP_D",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_GLO",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_D",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_EPHEMERIS_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(r.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 r.call(this,e),this.messageType="ObservationHeaderDep",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(r.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 r.call(this,e),this.messageType="CarrierPhaseDepA",this.fields=t||this.parser.parse(e.payload),this};(B.prototype=Object.create(r.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 r.call(this,e),this.messageType="PackedObsContentDepA",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(r.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 r.call(this,e),this.messageType="PackedObsContentDepB",this.fields=t||this.parser.parse(e.payload),this};(z.prototype=Object.create(r.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 r.call(this,e),this.messageType="PackedObsContentDepC",this.fields=t||this.parser.parse(e.payload),this};(H.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_OBS_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(V.prototype=Object.create(r.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:F.prototype.parser}).array("obs",{type:q.prototype.parser,readUntil:"eof"}),V.prototype.fieldSpec=[],V.prototype.fieldSpec.push(["header",F.prototype.fieldSpec]),V.prototype.fieldSpec.push(["obs","array",q.prototype.fieldSpec,function(){return this.fields.array.length},null]);var Y=function(e,t){return r.call(this,e),this.messageType="MSG_OBS_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(Y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_OBS_DEP_C",this.fields=t||this.parser.parse(e.payload),this};(W.prototype=Object.create(r.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:H.prototype.parser,readUntil:"eof"}),W.prototype.fieldSpec=[],W.prototype.fieldSpec.push(["header",F.prototype.fieldSpec]),W.prototype.fieldSpec.push(["obs","array",H.prototype.fieldSpec,function(){return this.fields.array.length},null]);var Q=function(e,t){return r.call(this,e),this.messageType="MSG_IONO",this.fields=t||this.parser.parse(e.payload),this};(Q.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SV_CONFIGURATION_GPS_DEP",this.fields=t||this.parser.parse(e.payload),this};(K.prototype=Object.create(r.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 r.call(this,e),this.messageType="GnssCapb",this.fields=t||this.parser.parse(e.payload),this};(X.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_GNSS_CAPB",this.fields=t||this.parser.parse(e.payload),this};(J.prototype=Object.create(r.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 Z=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(Z.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_DELAY_DEP_A",Z.prototype.msg_type=146,Z.prototype.constructor=Z,Z.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"),Z.prototype.fieldSpec=[],Z.prototype.fieldSpec.push(["t_op",l.prototype.fieldSpec]),Z.prototype.fieldSpec.push(["prn","writeUInt8",1]),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 $=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_B",this.fields=t||this.parser.parse(e.payload),this};($.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_DELAY_DEP_B",$.prototype.msg_type=147,$.prototype.constructor=$,$.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"),$.prototype.fieldSpec=[],$.prototype.fieldSpec.push(["t_op",c.prototype.fieldSpec]),$.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),$.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 ee=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY",this.fields=t||this.parser.parse(e.payload),this};(ee.prototype=Object.create(r.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 r.call(this,e),this.messageType="AlmanacCommonContent",this.fields=t||this.parser.parse(e.payload),this};(te.prototype=Object.create(r.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 pe=function(e,t){return r.call(this,e),this.messageType="AlmanacCommonContentDep",this.fields=t||this.parser.parse(e.payload),this};(pe.prototype=Object.create(r.prototype)).messageType="AlmanacCommonContentDep",pe.prototype.constructor=pe,pe.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"),pe.prototype.fieldSpec=[],pe.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),pe.prototype.fieldSpec.push(["toa",c.prototype.fieldSpec]),pe.prototype.fieldSpec.push(["ura","writeDoubleLE",8]),pe.prototype.fieldSpec.push(["fit_interval","writeUInt32LE",4]),pe.prototype.fieldSpec.push(["valid","writeUInt8",1]),pe.prototype.fieldSpec.push(["health_bits","writeUInt8",1]);var re=function(e,t){return r.call(this,e),this.messageType="MSG_ALMANAC_GPS_DEP",this.fields=t||this.parser.parse(e.payload),this};(re.prototype=Object.create(r.prototype)).messageType="MSG_ALMANAC_GPS_DEP",re.prototype.msg_type=112,re.prototype.constructor=re,re.prototype.parser=(new o).endianess("little").nest("common",{type:pe.prototype.parser}).doublele("m0").doublele("ecc").doublele("sqrta").doublele("omega0").doublele("omegadot").doublele("w").doublele("inc").doublele("af0").doublele("af1"),re.prototype.fieldSpec=[],re.prototype.fieldSpec.push(["common",pe.prototype.fieldSpec]),re.prototype.fieldSpec.push(["m0","writeDoubleLE",8]),re.prototype.fieldSpec.push(["ecc","writeDoubleLE",8]),re.prototype.fieldSpec.push(["sqrta","writeDoubleLE",8]),re.prototype.fieldSpec.push(["omega0","writeDoubleLE",8]),re.prototype.fieldSpec.push(["omegadot","writeDoubleLE",8]),re.prototype.fieldSpec.push(["w","writeDoubleLE",8]),re.prototype.fieldSpec.push(["inc","writeDoubleLE",8]),re.prototype.fieldSpec.push(["af0","writeDoubleLE",8]),re.prototype.fieldSpec.push(["af1","writeDoubleLE",8]);var oe=function(e,t){return r.call(this,e),this.messageType="MSG_ALMANAC_GPS",this.fields=t||this.parser.parse(e.payload),this};(oe.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ALMANAC_GLO_DEP",this.fields=t||this.parser.parse(e.payload),this};(ie.prototype=Object.create(r.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:pe.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",pe.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 r.call(this,e),this.messageType="MSG_ALMANAC_GLO",this.fields=t||this.parser.parse(e.payload),this};(se.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_GLO_BIASES",this.fields=t||this.parser.parse(e.payload),this};(ne.prototype=Object.create(r.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 r.call(this,e),this.messageType="SvAzEl",this.fields=t||this.parser.parse(e.payload),this};(ae.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SV_AZ_EL",this.fields=t||this.parser.parse(e.payload),this};(le.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_OSR",this.fields=t||this.parser.parse(e.payload),this};(ce.prototype=Object.create(r.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:I,MsgEphemerisGps:I,142:v,MsgEphemerisQzss:v,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:k,MsgEphemerisDepC:k,ObservationHeaderDep:F,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:Z,MsgGroupDelayDepA:Z,147:$,MsgGroupDelayDepB:$,148:ee,MsgGroupDelay:ee,AlmanacCommonContent:te,AlmanacCommonContentDep:pe,112:re,MsgAlmanacGpsDep:re,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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_BASELINE_HEADING",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ORIENT_QUAT",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ORIENT_EULER",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_ANGULAR_RATE",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=p(0).GnssSignalDep,n=p(0).GPSTime,a=p(0).GPSTimeDep,l=(p(0).GPSTimeSec,p(0).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_ALMANAC",this.fields=t||this.parser.parse(e.payload),this});(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SET_TIME",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_RESET",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_RESET_DEP",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_CW_RESULTS",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_CW_START",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_RESET_FILTERS",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_INIT_BASE_DEP",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_THREAD_STATE",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.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 r.call(this,e),this.messageType="UARTChannel",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.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 r.call(this,e),this.messageType="Period",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.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 r.call(this,e),this.messageType="Latency",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_UART_STATE",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_UART_STATE_DEPA",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.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 I=function(e,t){return r.call(this,e),this.messageType="MSG_IAR_STATE",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="MSG_IAR_STATE",I.prototype.msg_type=25,I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").uint32("num_hyps"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["num_hyps","writeUInt32LE",4]);var v=function(e,t){return r.call(this,e),this.messageType="MSG_MASK_SATELLITE",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_MASK_SATELLITE",v.prototype.msg_type=43,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").uint8("mask").nest("sid",{type:i.prototype.parser}),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["mask","writeUInt8",1]),v.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]);var L=function(e,t){return r.call(this,e),this.messageType="MSG_MASK_SATELLITE_DEP",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_DEVICE_MONITOR",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_COMMAND_REQ",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_COMMAND_RESP",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_COMMAND_OUTPUT",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_NETWORK_STATE_REQ",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_NETWORK_STATE_RESP",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.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 r.call(this,e),this.messageType="NetworkUsage",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_NETWORK_BANDWIDTH_USAGE",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_CELL_MODEM_STATUS",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SPECAN_DEP",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SPECAN",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_FRONT_END_GAIN",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.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:I,MsgIarState:I,43:v,MsgMaskSatellite:v,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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=(p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec,p(0).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_SBAS_RAW",this.fields=t||this.parser.parse(e.payload),this});(s.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_SETTINGS_SAVE",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_WRITE",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_WRITE_RESP",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_READ_REQ",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_READ_RESP",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_REQ",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_RESP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_READ_BY_INDEX_DONE",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_REGISTER",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SETTINGS_REGISTER_RESP",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="SolutionInputType",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SOLN_META_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SOLN_META",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="GNSSInputType",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="IMUInputType",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="OdoInputType",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase,p(0).GnssSignal),s=(p(0).GnssSignalDep,p(0).GPSTime,p(0).GPSTimeDep,p(0).GPSTimeSec),n=p(0).SvId,a=function(e,t){return r.call(this,e),this.messageType="CodeBiasesContent",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="PhaseBiasesContent",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="STECHeader",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="GriddedCorrectionHeader",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="STECSatElement",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="TroposphericDelayCorrectionNoStd",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="TroposphericDelayCorrection",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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 r.call(this,e),this.messageType="STECResidualNoStd",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.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 r.call(this,e),this.messageType="STECResidual",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SSR_CODE_BIASES",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SSR_PHASE_BIASES",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SSR_STEC_CORRECTION_DEP",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.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 r.call(this,e),this.messageType="BoundsHeader",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.prototype)).messageType="BoundsHeader",m.prototype.constructor=m,m.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("update_interval").uint8("sol_id"),m.prototype.fieldSpec=[],m.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),m.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),m.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),m.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),m.prototype.fieldSpec.push(["sol_id","writeUInt8",1]);var b=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_STEC_CORRECTION",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.prototype)).messageType="MSG_SSR_STEC_CORRECTION",b.prototype.msg_type=1533,b.prototype.constructor=b,b.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod_atmo").uint16("tile_set_id").uint16("tile_id").uint8("n_sats").array("stec_sat_list",{type:y.prototype.parser,length:"n_sats"}),b.prototype.fieldSpec=[],b.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),b.prototype.fieldSpec.push(["ssr_iod_atmo","writeUInt8",1]),b.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),b.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),b.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),b.prototype.fieldSpec.push(["stec_sat_list","array",y.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats"]);var I=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION",I.prototype.msg_type=1532,I.prototype.constructor=I,I.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"}),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["header",u.prototype.fieldSpec]),I.prototype.fieldSpec.push(["index","writeUInt16LE",2]),I.prototype.fieldSpec.push(["tropo_delay_correction",f.prototype.fieldSpec]),I.prototype.fieldSpec.push(["stec_residuals","array",_.prototype.fieldSpec,function(){return this.fields.array.length},null]);var v=function(e,t){return r.call(this,e),this.messageType="STECSatElementIntegrity",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="STECSatElementIntegrity",v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").nest("stec_residual",{type:_.prototype.parser}).uint8("stec_bound_mu").uint8("stec_bound_sig").uint8("stec_bound_mu_dot").uint8("stec_bound_sig_dot"),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["stec_residual",_.prototype.fieldSpec]),v.prototype.fieldSpec.push(["stec_bound_mu","writeUInt8",1]),v.prototype.fieldSpec.push(["stec_bound_sig","writeUInt8",1]),v.prototype.fieldSpec.push(["stec_bound_mu_dot","writeUInt8",1]),v.prototype.fieldSpec.push(["stec_bound_sig_dot","writeUInt8",1]);var L=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION_BOUNDS",this.fields=t||this.parser.parse(e.payload),this};(L.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_BOUNDS",L.prototype.msg_type=1534,L.prototype.constructor=L,L.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod_atmo").uint16("tile_set_id").uint16("tile_id").uint8("tropo_qi").uint16("grid_point_id").nest("tropo_delay_correction",{type:f.prototype.parser}).uint8("tropo_bound_mu").uint8("tropo_bound_sig").uint8("n_sats").array("stec_sat_list",{type:v.prototype.parser,length:"n_sats"}),L.prototype.fieldSpec=[],L.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),L.prototype.fieldSpec.push(["ssr_iod_atmo","writeUInt8",1]),L.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),L.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),L.prototype.fieldSpec.push(["tropo_qi","writeUInt8",1]),L.prototype.fieldSpec.push(["grid_point_id","writeUInt16LE",2]),L.prototype.fieldSpec.push(["tropo_delay_correction",f.prototype.fieldSpec]),L.prototype.fieldSpec.push(["tropo_bound_mu","writeUInt8",1]),L.prototype.fieldSpec.push(["tropo_bound_sig","writeUInt8",1]),L.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),L.prototype.fieldSpec.push(["stec_sat_list","array",v.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats"]);var T=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_TILE_DEFINITION_DEP",this.fields=t||this.parser.parse(e.payload),this};(T.prototype=Object.create(r.prototype)).messageType="MSG_SSR_TILE_DEFINITION_DEP",T.prototype.msg_type=1526,T.prototype.constructor=T,T.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"),T.prototype.fieldSpec=[],T.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),T.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),T.prototype.fieldSpec.push(["corner_nw_lat","writeInt16LE",2]),T.prototype.fieldSpec.push(["corner_nw_lon","writeInt16LE",2]),T.prototype.fieldSpec.push(["spacing_lat","writeUInt16LE",2]),T.prototype.fieldSpec.push(["spacing_lon","writeUInt16LE",2]),T.prototype.fieldSpec.push(["rows","writeUInt16LE",2]),T.prototype.fieldSpec.push(["cols","writeUInt16LE",2]),T.prototype.fieldSpec.push(["bitmask","writeUInt64LE",8]);var U=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_TILE_DEFINITION",this.fields=t||this.parser.parse(e.payload),this};(U.prototype=Object.create(r.prototype)).messageType="MSG_SSR_TILE_DEFINITION",U.prototype.msg_type=1527,U.prototype.constructor=U,U.prototype.parser=(new o).endianess("little").uint8("ssr_sol_id").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"),U.prototype.fieldSpec=[],U.prototype.fieldSpec.push(["ssr_sol_id","writeUInt8",1]),U.prototype.fieldSpec.push(["tile_set_id","writeUInt16LE",2]),U.prototype.fieldSpec.push(["tile_id","writeUInt16LE",2]),U.prototype.fieldSpec.push(["corner_nw_lat","writeInt16LE",2]),U.prototype.fieldSpec.push(["corner_nw_lon","writeInt16LE",2]),U.prototype.fieldSpec.push(["spacing_lat","writeUInt16LE",2]),U.prototype.fieldSpec.push(["spacing_lon","writeUInt16LE",2]),U.prototype.fieldSpec.push(["rows","writeUInt16LE",2]),U.prototype.fieldSpec.push(["cols","writeUInt16LE",2]),U.prototype.fieldSpec.push(["bitmask","writeUInt64LE",8]);var M=function(e,t){return r.call(this,e),this.messageType="SatelliteAPC",this.fields=t||this.parser.parse(e.payload),this};(M.prototype=Object.create(r.prototype)).messageType="SatelliteAPC",M.prototype.constructor=M,M.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"}),M.prototype.fieldSpec=[],M.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),M.prototype.fieldSpec.push(["sat_info","writeUInt8",1]),M.prototype.fieldSpec.push(["svn","writeUInt16LE",2]),M.prototype.fieldSpec.push(["pco","array","writeInt16LE",function(){return 2},3]),M.prototype.fieldSpec.push(["pcv","array","writeInt8",function(){return 1},21]);var D=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_SATELLITE_APC",this.fields=t||this.parser.parse(e.payload),this};(D.prototype=Object.create(r.prototype)).messageType="MSG_SSR_SATELLITE_APC",D.prototype.msg_type=1540,D.prototype.constructor=D,D.prototype.parser=(new o).endianess("little").array("apc",{type:M.prototype.parser,readUntil:"eof"}),D.prototype.fieldSpec=[],D.prototype.fieldSpec.push(["apc","array",M.prototype.fieldSpec,function(){return this.fields.array.length},null]);var O=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(O.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_DEP_A",O.prototype.msg_type=1500,O.prototype.constructor=O,O.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"),O.prototype.fieldSpec=[],O.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),O.prototype.fieldSpec.push(["sid",i.prototype.fieldSpec]),O.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),O.prototype.fieldSpec.push(["iod_ssr","writeUInt8",1]),O.prototype.fieldSpec.push(["iod","writeUInt8",1]),O.prototype.fieldSpec.push(["radial","writeInt32LE",4]),O.prototype.fieldSpec.push(["along","writeInt32LE",4]),O.prototype.fieldSpec.push(["cross","writeInt32LE",4]),O.prototype.fieldSpec.push(["dot_radial","writeInt32LE",4]),O.prototype.fieldSpec.push(["dot_along","writeInt32LE",4]),O.prototype.fieldSpec.push(["dot_cross","writeInt32LE",4]),O.prototype.fieldSpec.push(["c0","writeInt32LE",4]),O.prototype.fieldSpec.push(["c1","writeInt32LE",4]),O.prototype.fieldSpec.push(["c2","writeInt32LE",4]);var G=function(e,t){return r.call(this,e),this.messageType="STECHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(G.prototype=Object.create(r.prototype)).messageType="STECHeaderDepA",G.prototype.constructor=G,G.prototype.parser=(new o).endianess("little").nest("time",{type:s.prototype.parser}).uint8("num_msgs").uint8("seq_num").uint8("update_interval").uint8("iod_atmo"),G.prototype.fieldSpec=[],G.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),G.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),G.prototype.fieldSpec.push(["seq_num","writeUInt8",1]),G.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),G.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]);var A=function(e,t){return r.call(this,e),this.messageType="GriddedCorrectionHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(A.prototype=Object.create(r.prototype)).messageType="GriddedCorrectionHeaderDepA",A.prototype.constructor=A,A.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"),A.prototype.fieldSpec=[],A.prototype.fieldSpec.push(["time",s.prototype.fieldSpec]),A.prototype.fieldSpec.push(["num_msgs","writeUInt16LE",2]),A.prototype.fieldSpec.push(["seq_num","writeUInt16LE",2]),A.prototype.fieldSpec.push(["update_interval","writeUInt8",1]),A.prototype.fieldSpec.push(["iod_atmo","writeUInt8",1]),A.prototype.fieldSpec.push(["tropo_quality_indicator","writeUInt8",1]);var C=function(e,t){return r.call(this,e),this.messageType="GridDefinitionHeaderDepA",this.fields=t||this.parser.parse(e.payload),this};(C.prototype=Object.create(r.prototype)).messageType="GridDefinitionHeaderDepA",C.prototype.constructor=C,C.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"),C.prototype.fieldSpec=[],C.prototype.fieldSpec.push(["region_size_inverse","writeUInt8",1]),C.prototype.fieldSpec.push(["area_width","writeUInt16LE",2]),C.prototype.fieldSpec.push(["lat_nw_corner_enc","writeUInt16LE",2]),C.prototype.fieldSpec.push(["lon_nw_corner_enc","writeUInt16LE",2]),C.prototype.fieldSpec.push(["num_msgs","writeUInt8",1]),C.prototype.fieldSpec.push(["seq_num","writeUInt8",1]);var R=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_STEC_CORRECTION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(R.prototype=Object.create(r.prototype)).messageType="MSG_SSR_STEC_CORRECTION_DEP_A",R.prototype.msg_type=1515,R.prototype.constructor=R,R.prototype.parser=(new o).endianess("little").nest("header",{type:G.prototype.parser}).array("stec_sat_list",{type:y.prototype.parser,readUntil:"eof"}),R.prototype.fieldSpec=[],R.prototype.fieldSpec.push(["header",G.prototype.fieldSpec]),R.prototype.fieldSpec.push(["stec_sat_list","array",y.prototype.fieldSpec,function(){return this.fields.array.length},null]);var P=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(P.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A",P.prototype.msg_type=1520,P.prototype.constructor=P,P.prototype.parser=(new o).endianess("little").nest("header",{type:A.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:h.prototype.parser}).array("stec_residuals",{type:d.prototype.parser,readUntil:"eof"}),P.prototype.fieldSpec=[],P.prototype.fieldSpec.push(["header",A.prototype.fieldSpec]),P.prototype.fieldSpec.push(["index","writeUInt16LE",2]),P.prototype.fieldSpec.push(["tropo_delay_correction",h.prototype.fieldSpec]),P.prototype.fieldSpec.push(["stec_residuals","array",d.prototype.fieldSpec,function(){return this.fields.array.length},null]);var N=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRIDDED_CORRECTION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(N.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRIDDED_CORRECTION_DEP_A",N.prototype.msg_type=1530,N.prototype.constructor=N,N.prototype.parser=(new o).endianess("little").nest("header",{type:A.prototype.parser}).uint16("index").nest("tropo_delay_correction",{type:f.prototype.parser}).array("stec_residuals",{type:_.prototype.parser,readUntil:"eof"}),N.prototype.fieldSpec=[],N.prototype.fieldSpec.push(["header",A.prototype.fieldSpec]),N.prototype.fieldSpec.push(["index","writeUInt16LE",2]),N.prototype.fieldSpec.push(["tropo_delay_correction",f.prototype.fieldSpec]),N.prototype.fieldSpec.push(["stec_residuals","array",_.prototype.fieldSpec,function(){return this.fields.array.length},null]);var j=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_GRID_DEFINITION_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(j.prototype=Object.create(r.prototype)).messageType="MSG_SSR_GRID_DEFINITION_DEP_A",j.prototype.msg_type=1525,j.prototype.constructor=j,j.prototype.parser=(new o).endianess("little").nest("header",{type:C.prototype.parser}).array("rle_list",{type:"uint8",readUntil:"eof"}),j.prototype.fieldSpec=[],j.prototype.fieldSpec.push(["header",C.prototype.fieldSpec]),j.prototype.fieldSpec.push(["rle_list","array","writeUInt8",function(){return 1},null]);var x=function(e,t){return r.call(this,e),this.messageType="OrbitClockBound",this.fields=t||this.parser.parse(e.payload),this};(x.prototype=Object.create(r.prototype)).messageType="OrbitClockBound",x.prototype.constructor=x,x.prototype.parser=(new o).endianess("little").uint8("sat_id").uint8("orb_radial_bound_mu").uint8("orb_along_bound_mu").uint8("orb_cross_bound_mu").uint8("orb_radial_bound_sig").uint8("orb_along_bound_sig").uint8("orb_cross_bound_sig").uint8("clock_bound_mu").uint8("clock_bound_sig"),x.prototype.fieldSpec=[],x.prototype.fieldSpec.push(["sat_id","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_radial_bound_mu","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_along_bound_mu","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_cross_bound_mu","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_radial_bound_sig","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_along_bound_sig","writeUInt8",1]),x.prototype.fieldSpec.push(["orb_cross_bound_sig","writeUInt8",1]),x.prototype.fieldSpec.push(["clock_bound_mu","writeUInt8",1]),x.prototype.fieldSpec.push(["clock_bound_sig","writeUInt8",1]);var k=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS",this.fields=t||this.parser.parse(e.payload),this};(k.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS",k.prototype.msg_type=1502,k.prototype.constructor=k,k.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod").uint8("const_id").uint8("n_sats").array("orbit_clock_bounds",{type:x.prototype.parser,length:"n_sats"}),k.prototype.fieldSpec=[],k.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),k.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),k.prototype.fieldSpec.push(["const_id","writeUInt8",1]),k.prototype.fieldSpec.push(["n_sats","writeUInt8",1]),k.prototype.fieldSpec.push(["orbit_clock_bounds","array",x.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats"]);var F=function(e,t){return r.call(this,e),this.messageType="CodePhaseBiasesSatSig",this.fields=t||this.parser.parse(e.payload),this};(F.prototype=Object.create(r.prototype)).messageType="CodePhaseBiasesSatSig",F.prototype.constructor=F,F.prototype.parser=(new o).endianess("little").uint8("sat_id").uint8("signal_id").uint8("code_bias_bound_mu").uint8("code_bias_bound_sig").uint8("phase_bias_bound_mu").uint8("phase_bias_bound_sig"),F.prototype.fieldSpec=[],F.prototype.fieldSpec.push(["sat_id","writeUInt8",1]),F.prototype.fieldSpec.push(["signal_id","writeUInt8",1]),F.prototype.fieldSpec.push(["code_bias_bound_mu","writeUInt8",1]),F.prototype.fieldSpec.push(["code_bias_bound_sig","writeUInt8",1]),F.prototype.fieldSpec.push(["phase_bias_bound_mu","writeUInt8",1]),F.prototype.fieldSpec.push(["phase_bias_bound_sig","writeUInt8",1]);var B=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_CODE_PHASE_BIASES_BOUNDS",this.fields=t||this.parser.parse(e.payload),this};(B.prototype=Object.create(r.prototype)).messageType="MSG_SSR_CODE_PHASE_BIASES_BOUNDS",B.prototype.msg_type=1516,B.prototype.constructor=B,B.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod").uint8("const_id").uint8("n_sats_signals").array("satellites_signals",{type:F.prototype.parser,length:"n_sats_signals"}),B.prototype.fieldSpec=[],B.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),B.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),B.prototype.fieldSpec.push(["const_id","writeUInt8",1]),B.prototype.fieldSpec.push(["n_sats_signals","writeUInt8",1]),B.prototype.fieldSpec.push(["satellites_signals","array",F.prototype.fieldSpec,function(){return this.fields.array.length},"n_sats_signals"]);var q=function(e,t){return r.call(this,e),this.messageType="OrbitClockBoundDegradation",this.fields=t||this.parser.parse(e.payload),this};(q.prototype=Object.create(r.prototype)).messageType="OrbitClockBoundDegradation",q.prototype.constructor=q,q.prototype.parser=(new o).endianess("little").uint8("orb_radial_bound_mu_dot").uint8("orb_along_bound_mu_dot").uint8("orb_cross_bound_mu_dot").uint8("orb_radial_bound_sig_dot").uint8("orb_along_bound_sig_dot").uint8("orb_cross_bound_sig_dot").uint8("clock_bound_mu_dot").uint8("clock_bound_sig_dot"),q.prototype.fieldSpec=[],q.prototype.fieldSpec.push(["orb_radial_bound_mu_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_along_bound_mu_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_cross_bound_mu_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_radial_bound_sig_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_along_bound_sig_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["orb_cross_bound_sig_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["clock_bound_mu_dot","writeUInt8",1]),q.prototype.fieldSpec.push(["clock_bound_sig_dot","writeUInt8",1]);var z=function(e,t){return r.call(this,e),this.messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION",this.fields=t||this.parser.parse(e.payload),this};(z.prototype=Object.create(r.prototype)).messageType="MSG_SSR_ORBIT_CLOCK_BOUNDS_DEGRADATION",z.prototype.msg_type=1503,z.prototype.constructor=z,z.prototype.parser=(new o).endianess("little").nest("header",{type:m.prototype.parser}).uint8("ssr_iod").uint8("const_id").uint64("sat_bitmask").nest("orbit_clock_bounds_degradation",{type:q.prototype.parser}),z.prototype.fieldSpec=[],z.prototype.fieldSpec.push(["header",m.prototype.fieldSpec]),z.prototype.fieldSpec.push(["ssr_iod","writeUInt8",1]),z.prototype.fieldSpec.push(["const_id","writeUInt8",1]),z.prototype.fieldSpec.push(["sat_bitmask","writeUInt64LE",8]),z.prototype.fieldSpec.push(["orbit_clock_bounds_degradation",q.prototype.fieldSpec]),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,BoundsHeader:m,1533:b,MsgSsrStecCorrection:b,1532:I,MsgSsrGriddedCorrection:I,STECSatElementIntegrity:v,1534:L,MsgSsrGriddedCorrectionBounds:L,1526:T,MsgSsrTileDefinitionDep:T,1527:U,MsgSsrTileDefinition:U,SatelliteAPC:M,1540:D,MsgSsrSatelliteApc:D,1500:O,MsgSsrOrbitClockDepA:O,STECHeaderDepA:G,GriddedCorrectionHeaderDepA:A,GridDefinitionHeaderDepA:C,1515:R,MsgSsrStecCorrectionDepA:R,1520:P,MsgSsrGriddedCorrectionNoStdDepA:P,1530:N,MsgSsrGriddedCorrectionDepA:N,1525:j,MsgSsrGridDefinitionDepA:j,OrbitClockBound:x,1502:k,MsgSsrOrbitClockBounds:k,CodePhaseBiasesSatSig:F,1516:B,MsgSsrCodePhaseBiasesBounds:B,OrbitClockBoundDegradation:q,1503:z,MsgSsrOrbitClockBoundsDegradation:z}},function(e,t,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_STARTUP",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_DGNSS_STATUS",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_HEARTBEAT",this.fields=t||this.parser.parse(e.payload),this};(n.prototype=Object.create(r.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 r.call(this,e),this.messageType="SubSystemReport",this.fields=t||this.parser.parse(e.payload),this};(a.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_STATUS_REPORT",this.fields=t||this.parser.parse(e.payload),this};(l.prototype=Object.create(r.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 r.call(this,e),this.messageType="StatusJournalItem",this.fields=t||this.parser.parse(e.payload),this};(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_STATUS_JOURNAL",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_INS_STATUS",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_CSAC_TELEMETRY",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_CSAC_TELEMETRY_LABELS",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_INS_UPDATES",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_GNSS_TIME_OFFSET",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_PPS_TIME",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_SENSOR_AID_EVENT",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_GROUP_META",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,p(0).CarrierPhase),s=p(0).GnssSignal,n=p(0).GnssSignalDep,a=p(0).GPSTime,l=p(0).GPSTimeDep,c=(p(0).GPSTimeSec,p(0).SvId,function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_STATE_DETAILED_DEP_A",this.fields=t||this.parser.parse(e.payload),this});(c.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_TRACKING_STATE_DETAILED_DEP",this.fields=t||this.parser.parse(e.payload),this};(u.prototype=Object.create(r.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 r.call(this,e),this.messageType="TrackingChannelState",this.fields=t||this.parser.parse(e.payload),this};(y.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_TRACKING_STATE",this.fields=t||this.parser.parse(e.payload),this};(h.prototype=Object.create(r.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 r.call(this,e),this.messageType="MeasurementState",this.fields=t||this.parser.parse(e.payload),this};(f.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_MEASUREMENT_STATE",this.fields=t||this.parser.parse(e.payload),this};(d.prototype=Object.create(r.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 r.call(this,e),this.messageType="TrackingChannelCorrelation",this.fields=t||this.parser.parse(e.payload),this};(_.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_TRACKING_IQ",this.fields=t||this.parser.parse(e.payload),this};(S.prototype=Object.create(r.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 r.call(this,e),this.messageType="TrackingChannelCorrelationDep",this.fields=t||this.parser.parse(e.payload),this};(g.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_TRACKING_IQ_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(w.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_TRACKING_IQ_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(E.prototype=Object.create(r.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 r.call(this,e),this.messageType="TrackingChannelStateDepA",this.fields=t||this.parser.parse(e.payload),this};(m.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_TRACKING_STATE_DEP_A",this.fields=t||this.parser.parse(e.payload),this};(b.prototype=Object.create(r.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 I=function(e,t){return r.call(this,e),this.messageType="TrackingChannelStateDepB",this.fields=t||this.parser.parse(e.payload),this};(I.prototype=Object.create(r.prototype)).messageType="TrackingChannelStateDepB",I.prototype.constructor=I,I.prototype.parser=(new o).endianess("little").uint8("state").nest("sid",{type:n.prototype.parser}).floatle("cn0"),I.prototype.fieldSpec=[],I.prototype.fieldSpec.push(["state","writeUInt8",1]),I.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),I.prototype.fieldSpec.push(["cn0","writeFloatLE",4]);var v=function(e,t){return r.call(this,e),this.messageType="MSG_TRACKING_STATE_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(v.prototype=Object.create(r.prototype)).messageType="MSG_TRACKING_STATE_DEP_B",v.prototype.msg_type=19,v.prototype.constructor=v,v.prototype.parser=(new o).endianess("little").array("states",{type:I.prototype.parser,readUntil:"eof"}),v.prototype.fieldSpec=[],v.prototype.fieldSpec.push(["states","array",I.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:I,19:v,MsgTrackingStateDepB:v}},function(e,t,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_USER_DATA",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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,p){var r=p(2),o=p(4),i=(p(3),p(1).UINT64,function(e,t){return r.call(this,e),this.messageType="MSG_ODOMETRY",this.fields=t||this.parser.parse(e.payload),this});(i.prototype=Object.create(r.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 r.call(this,e),this.messageType="MSG_WHEELTICK",this.fields=t||this.parser.parse(e.payload),this};(s.prototype=Object.create(r.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/navigation.js b/javascript/sbp/navigation.js index 1f4ece4414..dfac76e112 100644 --- a/javascript/sbp/navigation.js +++ b/javascript/sbp/navigation.js @@ -2132,6 +2132,59 @@ 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 bias_coeff number (signed 16-bit int, 2 bytes) Reserved. Bias coefficient of GPS time scale with respect to UTC drift model. + * @field drift_coeff number (signed 16-bit int, 2 bytes) Reserved. Drift coefficient of GPS time scale with respect to UTC drift model. + * @field drift_rate_coeff number (signed 8-bit int, 1 byte) Reserved. Drift rate correction coefficient of GPS time scale with respect to + * UTC drift model. + * @field count_before number (signed 8-bit int, 1 byte) Leap second count before insertion. + * @field tow_s number (unsigned 16-bit int, 2 bytes) Reserved. Drift model reference week second. + * @field wn number (unsigned 16-bit int, 2 bytes) Reserved. Drift model reference week number. + * @field ref_wn number (unsigned 16-bit int, 2 bytes) Leap second reference week number. + * @field ref_dn number (unsigned 8-bit int, 1 byte) Leap second reference day number. + * @field count_after number (signed 8-bit int, 1 byte) Leap second count after insertion. + * + * @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') + .int16('bias_coeff') + .int16('drift_coeff') + .int8('drift_rate_coeff') + .int8('count_before') + .uint16('tow_s') + .uint16('wn') + .uint16('ref_wn') + .uint8('ref_dn') + .int8('count_after'); +MsgGpsLeapSecond.prototype.fieldSpec = []; +MsgGpsLeapSecond.prototype.fieldSpec.push(['bias_coeff', 'writeInt16LE', 2]); +MsgGpsLeapSecond.prototype.fieldSpec.push(['drift_coeff', 'writeInt16LE', 2]); +MsgGpsLeapSecond.prototype.fieldSpec.push(['drift_rate_coeff', 'writeInt8', 1]); +MsgGpsLeapSecond.prototype.fieldSpec.push(['count_before', 'writeInt8', 1]); +MsgGpsLeapSecond.prototype.fieldSpec.push(['tow_s', 'writeUInt16LE', 2]); +MsgGpsLeapSecond.prototype.fieldSpec.push(['wn', 'writeUInt16LE', 2]); +MsgGpsLeapSecond.prototype.fieldSpec.push(['ref_wn', 'writeUInt16LE', 2]); +MsgGpsLeapSecond.prototype.fieldSpec.push(['ref_dn', 'writeUInt8', 1]); +MsgGpsLeapSecond.prototype.fieldSpec.push(['count_after', 'writeInt8', 1]); + /** * SBP class for message MSG_ITRF (0x0244). * @@ -2300,6 +2353,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/jsonschema/MsgGPSLeapSecond.json b/jsonschema/MsgGPSLeapSecond.json new file mode 100644 index 0000000000..3aafff0ae3 --- /dev/null +++ b/jsonschema/MsgGPSLeapSecond.json @@ -0,0 +1,40 @@ +{ + "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": { + "bias_coeff": {"type": "integer"}, + "drift_coeff": {"type": "integer"}, + "drift_rate_coeff": {"type": "integer"}, + "count_before": {"type": "integer"}, + "tow_s": {"type": "integer"}, + "wn": {"type": "integer"}, + "ref_wn": {"type": "integer"}, + "ref_dn": {"type": "integer"}, + "count_after": {"type": "integer"} + }, + "required": [ + "bias_coeff", + "drift_coeff", + "drift_rate_coeff", + "count_before", + "tow_s", + "wn", + "ref_wn", + "ref_dn", + "count_after" + ] +} \ No newline at end of file diff --git a/proto/navigation.proto b/proto/navigation.proto index 133b166f13..99410a96d7 100644 --- a/proto/navigation.proto +++ b/proto/navigation.proto @@ -649,6 +649,24 @@ message MsgProtectionLevel { uint32 flags = 21; } +/** Leap second SBP message. + + * + * Emulates the GPS CNAV message, reserving bytes for future broadcast of the + * drift model parameters. + */ +message MsgGpsLeapSecond { + sint32 bias_coeff = 1; + sint32 drift_coeff = 2; + sint32 drift_rate_coeff = 3; + sint32 count_before = 4; + uint32 tow_s = 5; + uint32 wn = 6; + uint32 ref_wn = 7; + uint32 ref_dn = 8; + sint32 count_after = 9; +} + /** Reference Frame Transformation Parameter * None diff --git a/python/sbp/navigation.py b/python/sbp/navigation.py index e6fb13349e..ba88f64f38 100755 --- a/python/sbp/navigation.py +++ b/python/sbp/navigation.py @@ -5105,6 +5105,139 @@ 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. + bias_coeff : int + Reserved. Bias coefficient of GPS time scale with respect to UTC drift + model. + drift_coeff : int + Reserved. Drift coefficient of GPS time scale with respect to UTC drift + model. + drift_rate_coeff : int + Reserved. Drift rate correction coefficient of GPS time scale with respect + to UTC drift model. + count_before : int + Leap second count before insertion. + tow_s : int + Reserved. Drift model reference week second. + wn : int + Reserved. Drift model reference week number. + ref_wn : int + Leap second reference week number. + ref_dn : int + Leap second reference day number. + count_after : int + Leap second count after insertion. + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'bias_coeff' / construct.Int16sl, + 'drift_coeff' / construct.Int16sl, + 'drift_rate_coeff' / construct.Int8sl, + 'count_before' / construct.Int8sl, + 'tow_s' / construct.Int16ul, + 'wn' / construct.Int16ul, + 'ref_wn' / construct.Int16ul, + 'ref_dn' / construct.Int8ul, + 'count_after' / construct.Int8sl,) + __slots__ = [ + 'bias_coeff', + 'drift_coeff', + 'drift_rate_coeff', + 'count_before', + 'tow_s', + 'wn', + 'ref_wn', + 'ref_dn', + 'count_after', + ] + + 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.bias_coeff = kwargs.pop('bias_coeff') + self.drift_coeff = kwargs.pop('drift_coeff') + self.drift_rate_coeff = kwargs.pop('drift_rate_coeff') + self.count_before = kwargs.pop('count_before') + self.tow_s = kwargs.pop('tow_s') + self.wn = kwargs.pop('wn') + self.ref_wn = kwargs.pop('ref_wn') + self.ref_dn = kwargs.pop('ref_dn') + self.count_after = kwargs.pop('count_after') + + 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). @@ -5339,5 +5472,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/rust/sbp/src/messages/mod.rs b/rust/sbp/src/messages/mod.rs index 6ccba39e37..abefb54bf4 100644 --- a/rust/sbp/src/messages/mod.rs +++ b/rust/sbp/src/messages/mod.rs @@ -96,6 +96,7 @@ 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; @@ -650,6 +651,8 @@ 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 @@ -1580,6 +1583,11 @@ 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); @@ -2066,6 +2074,7 @@ 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(), @@ -2290,6 +2299,7 @@ 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(), @@ -2514,6 +2524,7 @@ 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(), @@ -2738,6 +2749,7 @@ 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), @@ -2962,6 +2974,7 @@ 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(), @@ -3189,6 +3202,7 @@ 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(), @@ -3421,6 +3435,7 @@ 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), @@ -3645,6 +3660,7 @@ 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), @@ -4638,6 +4654,12 @@ 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) diff --git a/rust/sbp/src/messages/navigation.rs b/rust/sbp/src/messages/navigation.rs index 626dcfa5e2..f6e79a53e5 100644 --- a/rust/sbp/src/messages/navigation.rs +++ b/rust/sbp/src/messages/navigation.rs @@ -45,6 +45,7 @@ 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; @@ -1685,6 +1686,138 @@ 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, + /// Reserved. Bias coefficient of GPS time scale with respect to UTC drift + /// model. + #[cfg_attr(feature = "serde", serde(rename(serialize = "bias_coeff")))] + pub bias_coeff: i16, + /// Reserved. Drift coefficient of GPS time scale with respect to UTC drift + /// model. + #[cfg_attr(feature = "serde", serde(rename(serialize = "drift_coeff")))] + pub drift_coeff: i16, + /// Reserved. Drift rate correction coefficient of GPS time scale with + /// respect to UTC drift model. + #[cfg_attr(feature = "serde", serde(rename(serialize = "drift_rate_coeff")))] + pub drift_rate_coeff: i8, + /// Leap second count before insertion. + #[cfg_attr(feature = "serde", serde(rename(serialize = "count_before")))] + pub count_before: i8, + /// Reserved. Drift model reference week second. + #[cfg_attr(feature = "serde", serde(rename(serialize = "tow_s")))] + pub tow_s: u16, + /// Reserved. Drift model reference week number. + #[cfg_attr(feature = "serde", serde(rename(serialize = "wn")))] + pub wn: u16, + /// Leap second reference week number. + #[cfg_attr(feature = "serde", serde(rename(serialize = "ref_wn")))] + pub ref_wn: u16, + /// Leap second reference day number. + #[cfg_attr(feature = "serde", serde(rename(serialize = "ref_dn")))] + pub ref_dn: u8, + /// Leap second count after insertion. + #[cfg_attr(feature = "serde", serde(rename(serialize = "count_after")))] + pub count_after: i8, + } + + 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 = ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.bias_coeff) + + WireFormat::len(&self.drift_coeff) + + WireFormat::len(&self.drift_rate_coeff) + + WireFormat::len(&self.count_before) + + WireFormat::len(&self.tow_s) + + WireFormat::len(&self.wn) + + WireFormat::len(&self.ref_wn) + + WireFormat::len(&self.ref_dn) + + WireFormat::len(&self.count_after) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.bias_coeff, buf); + WireFormat::write(&self.drift_coeff, buf); + WireFormat::write(&self.drift_rate_coeff, buf); + WireFormat::write(&self.count_before, buf); + WireFormat::write(&self.tow_s, buf); + WireFormat::write(&self.wn, buf); + WireFormat::write(&self.ref_wn, buf); + WireFormat::write(&self.ref_dn, buf); + WireFormat::write(&self.count_after, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgGpsLeapSecond { + sender_id: None, + bias_coeff: WireFormat::parse_unchecked(buf), + drift_coeff: WireFormat::parse_unchecked(buf), + drift_rate_coeff: WireFormat::parse_unchecked(buf), + count_before: WireFormat::parse_unchecked(buf), + tow_s: WireFormat::parse_unchecked(buf), + wn: WireFormat::parse_unchecked(buf), + ref_wn: WireFormat::parse_unchecked(buf), + ref_dn: WireFormat::parse_unchecked(buf), + count_after: WireFormat::parse_unchecked(buf), + } + } + } +} + pub mod msg_gps_time { #![allow(unused_imports)] 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..b8790f7f31 --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_navigation_msg_gps_leap_second.rs @@ -0,0 +1,95 @@ +// +// 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.bias_coeff, 1, + "incorrect value for bias_coeff, expected 1, is {}", + msg.bias_coeff + ); + assert_eq!( + msg.count_after, 9, + "incorrect value for count_after, expected 9, is {}", + msg.count_after + ); + assert_eq!( + msg.count_before, 4, + "incorrect value for count_before, expected 4, is {}", + msg.count_before + ); + assert_eq!( + msg.drift_coeff, 2, + "incorrect value for drift_coeff, expected 2, is {}", + msg.drift_coeff + ); + assert_eq!( + msg.drift_rate_coeff, 3, + "incorrect value for drift_rate_coeff, expected 3, is {}", + msg.drift_rate_coeff + ); + assert_eq!( + msg.ref_dn, 8, + "incorrect value for ref_dn, expected 8, is {}", + msg.ref_dn + ); + assert_eq!( + msg.ref_wn, 7, + "incorrect value for ref_wn, expected 7, is {}", + msg.ref_wn + ); + assert_eq!( + msg.tow_s, 5, + "incorrect value for tow_s, expected 5, is {}", + msg.tow_s + ); + assert_eq!( + msg.wn, 6, + "incorrect value for wn, expected 6, is {}", + msg.wn + ); + } + _ => 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/main.rs b/rust/sbp/tests/integration/main.rs index 5863442c03..1ccc5b3dbc 100644 --- a/rust/sbp/tests/integration/main.rs +++ b/rust/sbp/tests/integration/main.rs @@ -34,6 +34,7 @@ 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; diff --git a/sbpjson/elm/SbpJson.elm b/sbpjson/elm/SbpJson.elm index 487b7bf5cd..ac34d0aad0 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, boundsHeader, carrierPhase, codeBiasesContent, codePhaseBiasesSatSig, doppler, ephemerisCommonContent, estimatedHorizontalErrorEllipse, gnssInputType, gnssCapb, gnssSignal, gpsTime, gpsTimeSEC, gridElement, gridElementNoStd, griddedCorrectionHeader, imuInputType, integritySSRHeader, 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, 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, orbitClockBound, orbitClockBoundDegradation, packedObsContent, packedOsrContent, period, phaseBiasesContent, stecHeader, stecResidual, stecResidualNoStd, stecSatElement, stecSatElementIntegrity, satelliteAPC, solutionInputType, statusJournalItem, subSystemReport, svAzEl, svID, trackingChannelCorrelation, trackingChannelState, troposphericDelayCorrection, troposphericDelayCorrectionNoStd, uartChannel) +-- import SbpJson exposing (acqSvProfile, almanacCommonContent, boundsHeader, carrierPhase, codeBiasesContent, codePhaseBiasesSatSig, doppler, ephemerisCommonContent, estimatedHorizontalErrorEllipse, gnssInputType, gnssCapb, gnssSignal, gpsTime, gpsTimeSEC, gridElement, gridElementNoStd, griddedCorrectionHeader, imuInputType, integritySSRHeader, 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, orbitClockBound, orbitClockBoundDegradation, packedObsContent, packedOsrContent, period, phaseBiasesContent, stecHeader, stecResidual, stecResidualNoStd, stecSatElement, stecSatElementIntegrity, satelliteAPC, solutionInputType, statusJournalItem, subSystemReport, svAzEl, svID, trackingChannelCorrelation, trackingChannelState, troposphericDelayCorrection, troposphericDelayCorrectionNoStd, uartChannel) -- -- and you're off to the races with -- @@ -79,6 +79,7 @@ -- decodeString msgFlashReadResp myJsonString -- decodeString msgFrontEndGain myJsonString -- decodeString msgFwd myJsonString +-- decodeString msgGPSLeapSecond myJsonString -- decodeString msgGPSTime myJsonString -- decodeString msgGPSTimeGnss myJsonString -- decodeString msgGloBiases myJsonString @@ -426,6 +427,9 @@ module SbpJson exposing , MsgFwd , msgFwdToString , msgFwd + , MsgGPSLeapSecond + , msgGPSLeapSecondToString + , msgGPSLeapSecond , MsgGPSTime , msgGPSTimeToString , msgGPSTime @@ -1549,6 +1553,21 @@ type alias MsgFwd = , source : Int } +{-| Emulates the GPS CNAV message, reserving bytes for future broadcast of the drift model +parameters. +-} +type alias MsgGPSLeapSecond = + { biasCoeff : Int + , countAfter : Int + , countBefore : Int + , driftCoeff : Int + , driftRateCoeff : Int + , refDN : Int + , refWn : Int + , towS : Int + , wn : 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 @@ -3430,6 +3449,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) @@ -4962,6 +4984,33 @@ encodeMsgFwd x = , ("source", Jenc.int x.source) ] +msgGPSLeapSecond : Jdec.Decoder MsgGPSLeapSecond +msgGPSLeapSecond = + Jpipe.decode MsgGPSLeapSecond + |> Jpipe.required "bias_coeff" Jdec.int + |> Jpipe.required "count_after" Jdec.int + |> Jpipe.required "count_before" Jdec.int + |> Jpipe.required "drift_coeff" Jdec.int + |> Jpipe.required "drift_rate_coeff" Jdec.int + |> Jpipe.required "ref_dn" Jdec.int + |> Jpipe.required "ref_wn" Jdec.int + |> Jpipe.required "tow_s" Jdec.int + |> Jpipe.required "wn" Jdec.int + +encodeMsgGPSLeapSecond : MsgGPSLeapSecond -> Jenc.Value +encodeMsgGPSLeapSecond x = + Jenc.object + [ ("bias_coeff", Jenc.int x.biasCoeff) + , ("count_after", Jenc.int x.countAfter) + , ("count_before", Jenc.int x.countBefore) + , ("drift_coeff", Jenc.int x.driftCoeff) + , ("drift_rate_coeff", Jenc.int x.driftRateCoeff) + , ("ref_dn", Jenc.int x.refDN) + , ("ref_wn", Jenc.int x.refWn) + , ("tow_s", Jenc.int x.towS) + , ("wn", Jenc.int x.wn) + ] + msgGPSTime : Jdec.Decoder MsgGPSTime msgGPSTime = Jpipe.decode MsgGPSTime diff --git a/sbpjson/javascript/SbpJson.js b/sbpjson/javascript/SbpJson.js index 7c9ae014d3..05b595ffaf 100644 --- a/sbpjson/javascript/SbpJson.js +++ b/sbpjson/javascript/SbpJson.js @@ -72,6 +72,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); @@ -773,6 +774,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")); } @@ -2393,6 +2402,17 @@ const typeMap = { { json: "protocol", js: "protocol", typ: 0 }, { json: "source", js: "source", typ: 0 }, ], "any"), + "MsgGPSLeapSecond": o([ + { json: "bias_coeff", js: "bias_coeff", typ: 0 }, + { json: "count_after", js: "count_after", typ: 0 }, + { json: "count_before", js: "count_before", typ: 0 }, + { json: "drift_coeff", js: "drift_coeff", typ: 0 }, + { json: "drift_rate_coeff", js: "drift_rate_coeff", typ: 0 }, + { json: "ref_dn", js: "ref_dn", typ: 0 }, + { json: "ref_wn", js: "ref_wn", typ: 0 }, + { json: "tow_s", js: "tow_s", typ: 0 }, + { json: "wn", js: "wn", typ: 0 }, + ], "any"), "MsgGPSTime": o([ { json: "flags", js: "flags", typ: 0 }, { json: "ns_residual", js: "ns_residual", typ: 0 }, @@ -3549,6 +3569,8 @@ module.exports = { "toMsgFrontEndGain": toMsgFrontEndGain, "msgFwdToJson": msgFwdToJson, "toMsgFwd": toMsgFwd, + "msgGPSLeapSecondToJson": msgGPSLeapSecondToJson, + "toMsgGPSLeapSecond": toMsgGPSLeapSecond, "msgGPSTimeToJson": msgGPSTimeToJson, "toMsgGPSTime": toMsgGPSTime, "msgGPSTimeGnssToJson": msgGPSTimeGnssToJson, diff --git a/sbpjson/typescript/SbpJson.ts b/sbpjson/typescript/SbpJson.ts index 3e81dd0639..b126e11028 100644 --- a/sbpjson/typescript/SbpJson.ts +++ b/sbpjson/typescript/SbpJson.ts @@ -1,6 +1,6 @@ // To parse this data: // -// import { Convert, AcqSvProfile, AlmanacCommonContent, BoundsHeader, CarrierPhase, CodeBiasesContent, CodePhaseBiasesSatSig, Doppler, EphemerisCommonContent, EstimatedHorizontalErrorEllipse, GNSSInputType, GnssCapb, GnssSignal, GpsTime, GpsTimeSEC, GridElement, GridElementNoStd, GriddedCorrectionHeader, IMUInputType, IntegritySSRHeader, 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, 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, OrbitClockBound, OrbitClockBoundDegradation, PackedObsContent, PackedOsrContent, Period, PhaseBiasesContent, STECHeader, STECResidual, STECResidualNoStd, STECSatElement, STECSatElementIntegrity, SatelliteAPC, SolutionInputType, StatusJournalItem, SubSystemReport, SvAzEl, SvID, TrackingChannelCorrelation, TrackingChannelState, TroposphericDelayCorrection, TroposphericDelayCorrectionNoStd, UARTChannel } from "./file"; +// import { Convert, AcqSvProfile, AlmanacCommonContent, BoundsHeader, CarrierPhase, CodeBiasesContent, CodePhaseBiasesSatSig, Doppler, EphemerisCommonContent, EstimatedHorizontalErrorEllipse, GNSSInputType, GnssCapb, GnssSignal, GpsTime, GpsTimeSEC, GridElement, GridElementNoStd, GriddedCorrectionHeader, IMUInputType, IntegritySSRHeader, 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, OrbitClockBound, OrbitClockBoundDegradation, PackedObsContent, PackedOsrContent, Period, PhaseBiasesContent, STECHeader, STECResidual, STECResidualNoStd, STECSatElement, STECSatElementIntegrity, SatelliteAPC, SolutionInputType, StatusJournalItem, SubSystemReport, SvAzEl, SvID, TrackingChannelCorrelation, TrackingChannelState, TroposphericDelayCorrection, TroposphericDelayCorrectionNoStd, UARTChannel } from "./file"; // // const acqSvProfile = Convert.toAcqSvProfile(json); // const almanacCommonContent = Convert.toAlmanacCommonContent(json); @@ -72,6 +72,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); @@ -965,6 +966,22 @@ export interface MsgFwd { source: number; } +/** + * Emulates the GPS CNAV message, reserving bytes for future broadcast of the drift model + * parameters. + */ +export interface MsgGPSLeapSecond { + bias_coeff: number; + count_after: number; + count_before: number; + drift_coeff: number; + drift_rate_coeff: number; + ref_dn: number; + ref_wn: number; + tow_s: number; + wn: 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 @@ -3325,6 +3342,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")); } @@ -4946,6 +4971,17 @@ const typeMap: any = { { json: "protocol", js: "protocol", typ: 0 }, { json: "source", js: "source", typ: 0 }, ], "any"), + "MsgGPSLeapSecond": o([ + { json: "bias_coeff", js: "bias_coeff", typ: 0 }, + { json: "count_after", js: "count_after", typ: 0 }, + { json: "count_before", js: "count_before", typ: 0 }, + { json: "drift_coeff", js: "drift_coeff", typ: 0 }, + { json: "drift_rate_coeff", js: "drift_rate_coeff", typ: 0 }, + { json: "ref_dn", js: "ref_dn", typ: 0 }, + { json: "ref_wn", js: "ref_wn", typ: 0 }, + { json: "tow_s", js: "tow_s", typ: 0 }, + { json: "wn", js: "wn", typ: 0 }, + ], "any"), "MsgGPSTime": o([ { json: "flags", js: "flags", typ: 0 }, { json: "ns_residual", js: "ns_residual", typ: 0 },