From be78a791ed1eeeb3b76f7cd52de0df074595e9f0 Mon Sep 17 00:00:00 2001 From: fpezzinosn Date: Wed, 11 May 2022 17:56:09 -0400 Subject: [PATCH 1/3] Set new messages as private --- spec/yaml/swiftnav/sbp/ssr.yaml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/spec/yaml/swiftnav/sbp/ssr.yaml b/spec/yaml/swiftnav/sbp/ssr.yaml index a7b5bc1ca5..32a6c80959 100644 --- a/spec/yaml/swiftnav/sbp/ssr.yaml +++ b/spec/yaml/swiftnav/sbp/ssr.yaml @@ -485,6 +485,7 @@ definitions: - MSG_SSR_GRIDDED_CORRECTION_BOUNDS: id: 0x05FE short_desc: Gridded troposhere and STEC correction residuals bounds + public: False fields: - header: type: BoundsHeader @@ -645,6 +646,7 @@ definitions: Based on ETSI TS 137 355 V16.1.0 (LTE Positioning Protocol) information element GNSS-SSR-CorrectionPoints. SBP only supports gridded arrays of correction points, not lists of points. + public: False fields: - ssr_sol_id: type: u8 From 52a229d5aee8ce6a6f15ea8854f14a7feddfb241 Mon Sep 17 00:00:00 2001 From: fpezzinosn Date: Thu, 12 May 2022 09:58:55 -0400 Subject: [PATCH 2/3] Add transformation parameter message [OTA-149] --- python/tests/sbp/test_table.py | 2 +- .../swiftnav/sbp/navigation/test_MsgItrf.yaml | 47 ++++++++++ spec/yaml/swiftnav/sbp/navigation.yaml | 91 +++++++++++++++++++ 3 files changed, 139 insertions(+), 1 deletion(-) create mode 100644 spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml diff --git a/python/tests/sbp/test_table.py b/python/tests/sbp/test_table.py index 2f35619b22..c09dc0ccbf 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 = 217 + number_of_messages = 218 assert len(_SBP_TABLE) == number_of_messages def test_table_unqiue_count(): diff --git a/spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml b/spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml new file mode 100644 index 0000000000..04beccb51d --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml @@ -0,0 +1,47 @@ +description: Unit tests for swiftnav.sbp.navigation MsgItrf +generated_on: 2022-05-11 # manually generated +package: sbp.navigation +tests: + + - msg: + fields: + ssr_iod: 1 + sn_counter_n: 2 + sn: "foo\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" + tn_counter_m: 3 + tn: "bar\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" + sin: 4 + utn: 5 + re_t0: 6 + delta_X0: 7 + delta_Y0: 8 + delta_Z0: 9 + theta_01: 10 + theta_02: 11 + theta_03: 12 + scale: 13 + dot_delta_X0: 14 + dot_delta_Y0: 15 + dot_delta_Z0: 16 + dot_theta_01: 17 + dot_theta_02: 18 + dot_theta_03: 19 + dot_scale: 20 + module: sbp.navigation + name: MsgItrf + msg_type: '580' + raw_json: '{"ssr_iod": 1, "sn_counter_n": 2, "sn": "foo\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000", + "tn_counter_m": 3, "tn": "bar\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000", + "sin": 4, "utn": 5, "re_t0": 6, "delta_X0": 7, "delta_Y0": 8, "delta_Z0": 9, "theta_01": 10, "theta_02": 11, "theta_03": 12, "scale": 13, + "dot_delta_X0": 14, "dot_delta_Y0": 15, "dot_delta_Z0": 16, "dot_theta_01": 17, "dot_theta_02": 18, "dot_theta_03": 19, "dot_scale": 20, + "preamble": 85, "msg_type": 580, "sender": 66, "length": 124, + "payload": "AQJmb28AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2JhcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBQAGAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAABAAAAARAAAAEgAAABMAAAAUAA==", + "crc": 32322}' + raw_packet: VUQCQgB8AQJmb28AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2JhcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBQAGAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAABAAAAARAAAAEgAAABMAAAAUAEJ+ + sbp: + preamble: '0x55' + msg_type: '0x0244' + sender: '0x0042' + length: 124 + payload: AQJmb28AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2JhcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBQAGAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAABAAAAARAAAAEgAAABMAAAAUAA== + crc: '0x7E42' diff --git a/spec/yaml/swiftnav/sbp/navigation.yaml b/spec/yaml/swiftnav/sbp/navigation.yaml index d06bd5458b..c92066132f 100644 --- a/spec/yaml/swiftnav/sbp/navigation.yaml +++ b/spec/yaml/swiftnav/sbp/navigation.yaml @@ -2427,3 +2427,94 @@ definitions: desc: Safe state POPL - 31: desc: Safe state ROPL + + - MSG_ITRF: + id: 0x0244 + short_desc: Reference Frame Transformation Parameter + public: False + fields: + - ssr_iod: + type: u8 + desc: SSR IOD parameter. + - sn_counter_n: + type: u8 + desc: Source-Name Counter N. + - sn: + type: string + size: 31 + desc: Source-Name + - tn_counter_m: + type: u8 + desc: Target-Name Counter M. + - tn: + type: string + size: 31 + desc: Target-Name + - sin: + type: u8 + desc: System Identification Number. + - utn: + type: u16 + desc: Utilized Transformation Message. + - re_t0: + type: u16 + units: 1 day + desc: > + Reference Epoch t0 for transformation parameter set given as + Modified Julian Day (MDJ) Number minus 44244 days. + - delta_X0: + type: s32 + units: 0.001 m + desc: Translation in X for Reference Epoch t0. + - delta_Y0: + type: s32 + units: 0.001 m + desc: Translation in Y for Reference Epoch t0. + - delta_Z0: + type: s32 + units: 0.001 m + desc: Translation in Z for Reference Epoch t0. + - theta_01: + type: s32 + units: 0.00002 " + desc: Rotation around the X-axis for Reference Epoch t0. + - theta_02: + type: s32 + units: 0.00002 " + desc: Rotation around the Y-axis for Reference Epoch t0. + - theta_03: + type: s32 + units: 0.00002 " + desc: Rotation around the Z-axis for Reference Epoch t0. + - scale: + type: s32 + units: 0.00001 ppm + desc: Scale correction for Reference Epoch t0. + - dot_delta_X0: + type: s32 + units: 0.00002 m/yr + desc: Rate of change of translation in X. + - dot_delta_Y0: + type: s32 + units: 0.00002 m/yr + desc: Rate of change of translation in Y. + - dot_delta_Z0: + type: s32 + units: 0.00002 m/yr + desc: Rate of change of translation in Z. + - dot_theta_01: + type: s32 + units: 0.0000004 "/yr + desc: Rate of change of rotation around the X-axis. + - dot_theta_02: + type: s32 + units: 0.0000004 "/yr + desc: Rate of change of rotation around the Y-axis. + - dot_theta_03: + type: s32 + units: 0.0000004 "/yr + desc: Rate of change of rotation around the Z-axis. + - dot_scale: + type: s16 + units: 0.0000002 ppm/yr + desc: Rate of change of scale correction. From 38e545ad6c75d00d6dd08c767329b2eb7d1643e1 Mon Sep 17 00:00:00 2001 From: fpezzinosn Date: Thu, 12 May 2022 10:43:55 -0400 Subject: [PATCH 3/3] make all --- c/include/libsbp/cpp/message_traits.h | 30 ++ c/include/libsbp/legacy/cpp/message_traits.h | 6 + c/include/libsbp/legacy/navigation.h | 33 ++ c/include/libsbp/navigation_macros.h | 21 + c/include/libsbp/sbp_msg_type.h | 1 + c/include/libsbp/v4/navigation.h | 1 + c/include/libsbp/v4/navigation/MSG_ITRF.h | 277 ++++++++++++++ c/include/libsbp/v4/sbp_msg.h | 9 + c/src/include/libsbp/internal/v4/navigation.h | 19 + c/src/v4/navigation.c | 310 +++++++++++++++ c/test/auto_check_sbp_navigation_MsgItrf.c | 333 ++++++++++++++++ c/test/check_main.c | 1 + c/test/check_main_legacy.c | 1 + c/test/check_suites.h | 1 + c/test/check_suites_legacy.h | 1 + .../cpp/auto_check_sbp_navigation_MsgItrf.cc | 220 +++++++++++ .../auto_check_sbp_navigation_MsgItrf.c | 334 ++++++++++++++++ .../cpp/auto_check_sbp_navigation_MsgItrf.cc | 226 +++++++++++ docs/sbp.pdf | Bin 473183 -> 467608 bytes haskell/src/SwiftNav/SBP/Msg.hs | 6 + haskell/src/SwiftNav/SBP/Navigation.hs | 105 +++++ .../com/swiftnav/sbp/client/MessageTable.java | 3 + .../com/swiftnav/sbp/navigation/MsgItrf.java | 186 +++++++++ ...auto_check_sbp_navigation_MsgItrfTest.java | 358 ++++++++++++++++++ javascript/sbp.bundle.js | 2 +- javascript/sbp/navigation.js | 92 +++++ jsonschema/MsgItrf.json | 66 ++++ proto/navigation.proto | 29 ++ python/sbp/navigation.py | 195 ++++++++++ rust/sbp/src/messages/mod.rs | 22 ++ rust/sbp/src/messages/navigation.rs | 216 +++++++++++ .../auto_check_sbp_navigation_msg_itrf.rs | Bin 0 -> 6716 bytes rust/sbp/tests/integration/main.rs | 1 + sbpjson/elm/SbpJson.elm | 87 ++++- sbpjson/javascript/SbpJson.js | 35 ++ sbpjson/typescript/SbpJson.ts | 60 ++- 36 files changed, 3284 insertions(+), 3 deletions(-) create mode 100644 c/include/libsbp/v4/navigation/MSG_ITRF.h create mode 100644 c/test/auto_check_sbp_navigation_MsgItrf.c create mode 100644 c/test/cpp/auto_check_sbp_navigation_MsgItrf.cc create mode 100644 c/test/legacy/auto_check_sbp_navigation_MsgItrf.c create mode 100644 c/test/legacy/cpp/auto_check_sbp_navigation_MsgItrf.cc create mode 100644 java/src/com/swiftnav/sbp/navigation/MsgItrf.java create mode 100644 java/test/auto_check_sbp_navigation_MsgItrfTest.java create mode 100644 jsonschema/MsgItrf.json create mode 100644 rust/sbp/tests/integration/auto_check_sbp_navigation_msg_itrf.rs diff --git a/c/include/libsbp/cpp/message_traits.h b/c/include/libsbp/cpp/message_traits.h index 8fee293e95..3e689e61e7 100644 --- a/c/include/libsbp/cpp/message_traits.h +++ b/c/include/libsbp/cpp/message_traits.h @@ -3199,6 +3199,36 @@ struct MessageTraits { } }; +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgItrf; + static const sbp_msg_itrf_t &get(const sbp_msg_t &msg) { return msg.itrf; } + static sbp_msg_itrf_t &get(sbp_msg_t &msg) { return msg.itrf; } + static void to_sbp_msg(const sbp_msg_itrf_t &msg, sbp_msg_t *sbp_msg) { + sbp_msg->itrf = msg; + } + static sbp_msg_t to_sbp_msg(const sbp_msg_itrf_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.itrf = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, const sbp_msg_itrf_t &msg, + sbp_write_fn_t write) { + return sbp_msg_itrf_send(state, sender_id, &msg, write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_itrf_t &msg) { + return sbp_msg_itrf_encode(buf, len, n_written, &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_itrf_t *msg) { + return sbp_msg_itrf_decode(buf, len, n_read, msg); + } + static size_t encoded_len(const sbp_msg_itrf_t &msg) { + return sbp_msg_itrf_encoded_len(&msg); + } +}; + template <> struct MessageTraits { static constexpr sbp_msg_type_t id = SbpMsgLinuxCpuStateDepA; diff --git a/c/include/libsbp/legacy/cpp/message_traits.h b/c/include/libsbp/legacy/cpp/message_traits.h index 53b815ded2..150af8d2b9 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 = 580; +}; + + template<> struct MessageTraits { static constexpr u16 id = 1024; diff --git a/c/include/libsbp/legacy/navigation.h b/c/include/libsbp/legacy/navigation.h index 06c1673222..8002b3b6a2 100644 --- a/c/include/libsbp/legacy/navigation.h +++ b/c/include/libsbp/legacy/navigation.h @@ -919,6 +919,39 @@ typedef struct SBP_ATTR_PACKED { u32 flags; /**< Status flags */ } msg_protection_level_t; +typedef struct SBP_ATTR_PACKED { + u8 ssr_iod; /**< SSR IOD parameter. */ + u8 sn_counter_n; /**< Source-Name Counter N. */ + char sn[31]; /**< Source-Name */ + u8 tn_counter_m; /**< Target-Name Counter M. */ + char tn[31]; /**< Target-Name */ + u8 sin; /**< System Identification Number. */ + u16 utn; /**< Utilized Transformation Message. */ + u16 re_t0; /**< Reference Epoch t0 for transformation parameter + set given as Modified Julian Day (MDJ) Number + minus 44244 days. [1 day] */ + s32 delta_X0; /**< Translation in X for Reference Epoch t0. [0.001 m] */ + s32 delta_Y0; /**< Translation in Y for Reference Epoch t0. [0.001 m] */ + s32 delta_Z0; /**< Translation in Z for Reference Epoch t0. [0.001 m] */ + s32 theta_01; /**< Rotation around the X-axis for Reference Epoch t0. [0.00002 + "] */ + s32 theta_02; /**< Rotation around the Y-axis for Reference Epoch t0. [0.00002 + "] */ + s32 theta_03; /**< Rotation around the Z-axis for Reference Epoch t0. [0.00002 + "] */ + s32 scale; /**< Scale correction for Reference Epoch t0. [0.00001 ppm] */ + s32 dot_delta_X0; /**< Rate of change of translation in X. [0.00002 m/yr] */ + s32 dot_delta_Y0; /**< Rate of change of translation in Y. [0.00002 m/yr] */ + s32 dot_delta_Z0; /**< Rate of change of translation in Z. [0.00002 m/yr] */ + s32 dot_theta_01; /**< Rate of change of rotation around the X-axis. + [0.0000004 "/yr] */ + s32 dot_theta_02; /**< Rate of change of rotation around the Y-axis. + [0.0000004 "/yr] */ + s32 dot_theta_03; /**< Rate of change of rotation around the Z-axis. + [0.0000004 "/yr] */ + s16 dot_scale; /**< Rate of change of scale correction. [0.0000002 ppm/yr] */ +} msg_itrf_t; + /** \} */ SBP_PACK_END diff --git a/c/include/libsbp/navigation_macros.h b/c/include/libsbp/navigation_macros.h index 886b77ff02..a65f792046 100644 --- a/c/include/libsbp/navigation_macros.h +++ b/c/include/libsbp/navigation_macros.h @@ -1736,4 +1736,25 @@ */ #define SBP_MSG_PROTECTION_LEVEL_ENCODED_LEN 76u +#define SBP_MSG_ITRF 0x0244 +/** + * The maximum number of items that can be stored in sbp_msg_itrf_t::sn (V4 API) + * or msg_itrf_t::sn (legacy API) before the maximum SBP message size is + * exceeded + */ +#define SBP_MSG_ITRF_SN_MAX 31u + +/** + * The maximum number of items that can be stored in sbp_msg_itrf_t::tn (V4 API) + * or msg_itrf_t::tn (legacy API) before the maximum SBP message size is + * exceeded + */ +#define SBP_MSG_ITRF_TN_MAX 31u + +/** + * Encoded length of sbp_msg_itrf_t (V4 API) and + * msg_itrf_t (legacy API) + */ +#define SBP_MSG_ITRF_ENCODED_LEN 124u + #endif /* LIBSBP_NAVIGATION_MACROS_H */ diff --git a/c/include/libsbp/sbp_msg_type.h b/c/include/libsbp/sbp_msg_type.h index ec5f1af697..4c58fe9b10 100644 --- a/c/include/libsbp/sbp_msg_type.h +++ b/c/include/libsbp/sbp_msg_type.h @@ -142,6 +142,7 @@ typedef enum { SbpMsgInsStatus = SBP_MSG_INS_STATUS, SbpMsgInsUpdates = SBP_MSG_INS_UPDATES, SbpMsgIono = SBP_MSG_IONO, + SbpMsgItrf = SBP_MSG_ITRF, SbpMsgLinuxCpuStateDepA = SBP_MSG_LINUX_CPU_STATE_DEP_A, SbpMsgLinuxCpuState = SBP_MSG_LINUX_CPU_STATE, SbpMsgLinuxMemStateDepA = SBP_MSG_LINUX_MEM_STATE_DEP_A, diff --git a/c/include/libsbp/v4/navigation.h b/c/include/libsbp/v4/navigation.h index ae2060d7ca..0b46e71927 100644 --- a/c/include/libsbp/v4/navigation.h +++ b/c/include/libsbp/v4/navigation.h @@ -29,6 +29,7 @@ #include #include #include +#include #include #include #include diff --git a/c/include/libsbp/v4/navigation/MSG_ITRF.h b/c/include/libsbp/v4/navigation/MSG_ITRF.h new file mode 100644 index 0000000000..361db39f5c --- /dev/null +++ b/c/include/libsbp/v4/navigation/MSG_ITRF.h @@ -0,0 +1,277 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/navigation.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_V4_NAVIGATION_MSG_ITRF_H +#define LIBSBP_V4_NAVIGATION_MSG_ITRF_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_ITRF + * + *****************************************************************************/ +typedef struct { + /** + * SSR IOD parameter. + */ + u8 ssr_iod; + + /** + * Source-Name Counter N. + */ + u8 sn_counter_n; + + /** + * Source-Name + */ + char sn[SBP_MSG_ITRF_SN_MAX]; + + /** + * Target-Name Counter M. + */ + u8 tn_counter_m; + + /** + * Target-Name + */ + char tn[SBP_MSG_ITRF_TN_MAX]; + + /** + * System Identification Number. + */ + u8 sin; + + /** + * Utilized Transformation Message. + */ + u16 utn; + + /** + * Reference Epoch t0 for transformation parameter set given as Modified + * Julian Day (MDJ) Number minus 44244 days. [1 day] + */ + u16 re_t0; + + /** + * Translation in X for Reference Epoch t0. [0.001 m] + */ + s32 delta_X0; + + /** + * Translation in Y for Reference Epoch t0. [0.001 m] + */ + s32 delta_Y0; + + /** + * Translation in Z for Reference Epoch t0. [0.001 m] + */ + s32 delta_Z0; + + /** + * Rotation around the X-axis for Reference Epoch t0. [0.00002 "] + */ + s32 theta_01; + + /** + * Rotation around the Y-axis for Reference Epoch t0. [0.00002 "] + */ + s32 theta_02; + + /** + * Rotation around the Z-axis for Reference Epoch t0. [0.00002 "] + */ + s32 theta_03; + + /** + * Scale correction for Reference Epoch t0. [0.00001 ppm] + */ + s32 scale; + + /** + * Rate of change of translation in X. [0.00002 m/yr] + */ + s32 dot_delta_X0; + + /** + * Rate of change of translation in Y. [0.00002 m/yr] + */ + s32 dot_delta_Y0; + + /** + * Rate of change of translation in Z. [0.00002 m/yr] + */ + s32 dot_delta_Z0; + + /** + * Rate of change of rotation around the X-axis. [0.0000004 "/yr] + */ + s32 dot_theta_01; + + /** + * Rate of change of rotation around the Y-axis. [0.0000004 "/yr] + */ + s32 dot_theta_02; + + /** + * Rate of change of rotation around the Z-axis. [0.0000004 "/yr] + */ + s32 dot_theta_03; + + /** + * Rate of change of scale correction. [0.0000002 ppm/yr] + */ + s16 dot_scale; +} sbp_msg_itrf_t; + +/** + * Get encoded size of an instance of sbp_msg_itrf_t + * + * @param msg sbp_msg_itrf_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_itrf_encoded_len(const sbp_msg_itrf_t *msg) { + (void)msg; + return SBP_MSG_ITRF_ENCODED_LEN; +} + +/** + * Encode an instance of sbp_msg_itrf_t to wire representation + * + * This function encodes the given instance in to the user provided buffer. The + * buffer provided to this function must be large enough to store the encoded + * message otherwise it will return SBP_ENCODE_ERROR without writing anything to + * the buffer. + * + * Specify the length of the destination buffer in the \p len parameter. If + * non-null the number of bytes written to the buffer will be returned in \p + * n_written. + * + * @param buf Destination buffer + * @param len Length of \p buf + * @param n_written If not null, on success will be set to the number of bytes + * written to \p buf + * @param msg Instance of sbp_msg_itrf_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_itrf_encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_itrf_t *msg); + +/** + * Decode an instance of sbp_msg_itrf_t from wire representation + * + * This function decodes the wire representation of a sbp_msg_itrf_t message to + * the given instance. The caller must specify the length of the buffer in the + * \p len parameter. If non-null the number of bytes read from the buffer will + * be returned in \p n_read. + * + * @param buf Wire representation of the sbp_msg_itrf_t instance + * @param len Length of \p buf + * @param n_read If not null, on success will be set to the number of bytes read + * from \p buf + * @param msg Destination + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_itrf_decode(const uint8_t *buf, uint8_t len, + uint8_t *n_read, sbp_msg_itrf_t *msg); +/** + * Send an instance of sbp_msg_itrf_t with the given write function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_itrf_t + * + * The given message will be encoded to wire representation and passed in to the + * given write function callback. The write callback will be called several + * times for each invocation of this function. + * + * @param s SBP state + * @param sender_id SBP sender id + * @param msg Message to send + * @param write Write function + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_itrf_send(sbp_state_t *s, u16 sender_id, + const sbp_msg_itrf_t *msg, + sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_itrf_t + * + * The two instances will be compared and a value returned consistent with the + * return codes of comparison functions from the C standard library + * + * 0 will be returned if \p a and \p b are considered equal + * A value less than 0 will be returned if \p a is considered to be less than \p + * b A value greater than 0 will be returned if \p b is considered to be greater + * than \p b + * + * @param a sbp_msg_itrf_t instance + * @param b sbp_msg_itrf_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_itrf_cmp(const sbp_msg_itrf_t *a, + const sbp_msg_itrf_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==(const sbp_msg_itrf_t &lhs, + const sbp_msg_itrf_t &rhs) { + return sbp_msg_itrf_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=(const sbp_msg_itrf_t &lhs, + const sbp_msg_itrf_t &rhs) { + return sbp_msg_itrf_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<(const sbp_msg_itrf_t &lhs, + const sbp_msg_itrf_t &rhs) { + return sbp_msg_itrf_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=(const sbp_msg_itrf_t &lhs, + const sbp_msg_itrf_t &rhs) { + return sbp_msg_itrf_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>(const sbp_msg_itrf_t &lhs, + const sbp_msg_itrf_t &rhs) { + return sbp_msg_itrf_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=(const sbp_msg_itrf_t &lhs, + const sbp_msg_itrf_t &rhs) { + return sbp_msg_itrf_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_V4_NAVIGATION_MSG_ITRF_H */ diff --git a/c/include/libsbp/v4/sbp_msg.h b/c/include/libsbp/v4/sbp_msg.h index d34875fdbb..8f8a73eb4d 100644 --- a/c/include/libsbp/v4/sbp_msg.h +++ b/c/include/libsbp/v4/sbp_msg.h @@ -148,6 +148,7 @@ typedef union { sbp_msg_ins_status_t ins_status; sbp_msg_ins_updates_t ins_updates; sbp_msg_iono_t iono; + sbp_msg_itrf_t itrf; sbp_msg_linux_cpu_state_dep_a_t linux_cpu_state_dep_a; sbp_msg_linux_cpu_state_t linux_cpu_state; sbp_msg_linux_mem_state_dep_a_t linux_mem_state_dep_a; @@ -542,6 +543,8 @@ static inline s8 sbp_message_encode(uint8_t *buf, uint8_t len, return sbp_msg_ins_updates_encode(buf, len, n_written, &msg->ins_updates); case SbpMsgIono: return sbp_msg_iono_encode(buf, len, n_written, &msg->iono); + case SbpMsgItrf: + return sbp_msg_itrf_encode(buf, len, n_written, &msg->itrf); case SbpMsgLinuxCpuStateDepA: return sbp_msg_linux_cpu_state_dep_a_encode(buf, len, n_written, &msg->linux_cpu_state_dep_a); @@ -1151,6 +1154,8 @@ static inline s8 sbp_message_decode(const uint8_t *buf, uint8_t len, return sbp_msg_ins_updates_decode(buf, len, n_read, &msg->ins_updates); case SbpMsgIono: return sbp_msg_iono_decode(buf, len, n_read, &msg->iono); + case SbpMsgItrf: + return sbp_msg_itrf_decode(buf, len, n_read, &msg->itrf); case SbpMsgLinuxCpuStateDepA: return sbp_msg_linux_cpu_state_dep_a_decode(buf, len, n_read, &msg->linux_cpu_state_dep_a); @@ -1697,6 +1702,8 @@ static inline size_t sbp_message_encoded_len(sbp_msg_type_t msg_type, return sbp_msg_ins_updates_encoded_len(&msg->ins_updates); case SbpMsgIono: return sbp_msg_iono_encoded_len(&msg->iono); + case SbpMsgItrf: + return sbp_msg_itrf_encoded_len(&msg->itrf); case SbpMsgLinuxCpuStateDepA: return sbp_msg_linux_cpu_state_dep_a_encoded_len( &msg->linux_cpu_state_dep_a); @@ -2230,6 +2237,8 @@ static inline int sbp_message_cmp(sbp_msg_type_t msg_type, const sbp_msg_t *a, return sbp_msg_ins_updates_cmp(&a->ins_updates, &b->ins_updates); case SbpMsgIono: return sbp_msg_iono_cmp(&a->iono, &b->iono); + case SbpMsgItrf: + return sbp_msg_itrf_cmp(&a->itrf, &b->itrf); case SbpMsgLinuxCpuStateDepA: return sbp_msg_linux_cpu_state_dep_a_cmp(&a->linux_cpu_state_dep_a, &b->linux_cpu_state_dep_a); diff --git a/c/src/include/libsbp/internal/v4/navigation.h b/c/src/include/libsbp/internal/v4/navigation.h index df635d37c8..6f7e403680 100644 --- a/c/src/include/libsbp/internal/v4/navigation.h +++ b/c/src/include/libsbp/internal/v4/navigation.h @@ -806,6 +806,25 @@ 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_itrf_encode_internal(sbp_encode_ctx_t *ctx, + const sbp_msg_itrf_t *msg); + +/** + * Internal function to decode an SBP type from a buffer + * + * @param ctx Decode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_itrf_decode_internal(sbp_decode_ctx_t *ctx, sbp_msg_itrf_t *msg); + #ifdef __cplusplus } #endif diff --git a/c/src/v4/navigation.c b/c/src/v4/navigation.c index fbf90beca2..1d56ee2068 100644 --- a/c/src/v4/navigation.c +++ b/c/src/v4/navigation.c @@ -5971,3 +5971,313 @@ int sbp_msg_protection_level_cmp(const sbp_msg_protection_level_t *a, } 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)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->sn_counter_n)) { + return false; + } + for (size_t i = 0; i < SBP_MSG_ITRF_SN_MAX; i++) { + if (!sbp_char_encode(ctx, &msg->sn[i])) { + return false; + } + } + if (!sbp_u8_encode(ctx, &msg->tn_counter_m)) { + return false; + } + for (size_t i = 0; i < SBP_MSG_ITRF_TN_MAX; i++) { + if (!sbp_char_encode(ctx, &msg->tn[i])) { + return false; + } + } + if (!sbp_u8_encode(ctx, &msg->sin)) { + return false; + } + if (!sbp_u16_encode(ctx, &msg->utn)) { + return false; + } + if (!sbp_u16_encode(ctx, &msg->re_t0)) { + return false; + } + if (!sbp_s32_encode(ctx, &msg->delta_X0)) { + return false; + } + if (!sbp_s32_encode(ctx, &msg->delta_Y0)) { + return false; + } + if (!sbp_s32_encode(ctx, &msg->delta_Z0)) { + return false; + } + if (!sbp_s32_encode(ctx, &msg->theta_01)) { + return false; + } + if (!sbp_s32_encode(ctx, &msg->theta_02)) { + return false; + } + if (!sbp_s32_encode(ctx, &msg->theta_03)) { + return false; + } + if (!sbp_s32_encode(ctx, &msg->scale)) { + return false; + } + if (!sbp_s32_encode(ctx, &msg->dot_delta_X0)) { + return false; + } + if (!sbp_s32_encode(ctx, &msg->dot_delta_Y0)) { + return false; + } + if (!sbp_s32_encode(ctx, &msg->dot_delta_Z0)) { + return false; + } + if (!sbp_s32_encode(ctx, &msg->dot_theta_01)) { + return false; + } + if (!sbp_s32_encode(ctx, &msg->dot_theta_02)) { + return false; + } + if (!sbp_s32_encode(ctx, &msg->dot_theta_03)) { + return false; + } + if (!sbp_s16_encode(ctx, &msg->dot_scale)) { + return false; + } + return true; +} + +s8 sbp_msg_itrf_encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_itrf_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_itrf_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_itrf_decode_internal(sbp_decode_ctx_t *ctx, sbp_msg_itrf_t *msg) { + if (!sbp_u8_decode(ctx, &msg->ssr_iod)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->sn_counter_n)) { + return false; + } + for (uint8_t i = 0; i < SBP_MSG_ITRF_SN_MAX; i++) { + if (!sbp_char_decode(ctx, &msg->sn[i])) { + return false; + } + } + if (!sbp_u8_decode(ctx, &msg->tn_counter_m)) { + return false; + } + for (uint8_t i = 0; i < SBP_MSG_ITRF_TN_MAX; i++) { + if (!sbp_char_decode(ctx, &msg->tn[i])) { + return false; + } + } + if (!sbp_u8_decode(ctx, &msg->sin)) { + return false; + } + if (!sbp_u16_decode(ctx, &msg->utn)) { + return false; + } + if (!sbp_u16_decode(ctx, &msg->re_t0)) { + return false; + } + if (!sbp_s32_decode(ctx, &msg->delta_X0)) { + return false; + } + if (!sbp_s32_decode(ctx, &msg->delta_Y0)) { + return false; + } + if (!sbp_s32_decode(ctx, &msg->delta_Z0)) { + return false; + } + if (!sbp_s32_decode(ctx, &msg->theta_01)) { + return false; + } + if (!sbp_s32_decode(ctx, &msg->theta_02)) { + return false; + } + if (!sbp_s32_decode(ctx, &msg->theta_03)) { + return false; + } + if (!sbp_s32_decode(ctx, &msg->scale)) { + return false; + } + if (!sbp_s32_decode(ctx, &msg->dot_delta_X0)) { + return false; + } + if (!sbp_s32_decode(ctx, &msg->dot_delta_Y0)) { + return false; + } + if (!sbp_s32_decode(ctx, &msg->dot_delta_Z0)) { + return false; + } + if (!sbp_s32_decode(ctx, &msg->dot_theta_01)) { + return false; + } + if (!sbp_s32_decode(ctx, &msg->dot_theta_02)) { + return false; + } + if (!sbp_s32_decode(ctx, &msg->dot_theta_03)) { + return false; + } + if (!sbp_s16_decode(ctx, &msg->dot_scale)) { + return false; + } + return true; +} + +s8 sbp_msg_itrf_decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_itrf_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_itrf_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_itrf_send(sbp_state_t *s, u16 sender_id, const sbp_msg_itrf_t *msg, + sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = sbp_msg_itrf_encode(payload, sizeof(payload), &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_payload_send(s, SBP_MSG_ITRF, sender_id, payload_len, payload, + write); +} + +int sbp_msg_itrf_cmp(const sbp_msg_itrf_t *a, const sbp_msg_itrf_t *b) { + int ret = 0; + + ret = sbp_u8_cmp(&a->ssr_iod, &b->ssr_iod); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->sn_counter_n, &b->sn_counter_n); + if (ret != 0) { + return ret; + } + + for (uint8_t i = 0; ret == 0 && i < SBP_MSG_ITRF_SN_MAX; i++) { + ret = sbp_char_cmp(&a->sn[i], &b->sn[i]); + } + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->tn_counter_m, &b->tn_counter_m); + if (ret != 0) { + return ret; + } + + for (uint8_t i = 0; ret == 0 && i < SBP_MSG_ITRF_TN_MAX; i++) { + ret = sbp_char_cmp(&a->tn[i], &b->tn[i]); + } + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->sin, &b->sin); + if (ret != 0) { + return ret; + } + + ret = sbp_u16_cmp(&a->utn, &b->utn); + if (ret != 0) { + return ret; + } + + ret = sbp_u16_cmp(&a->re_t0, &b->re_t0); + if (ret != 0) { + return ret; + } + + ret = sbp_s32_cmp(&a->delta_X0, &b->delta_X0); + if (ret != 0) { + return ret; + } + + ret = sbp_s32_cmp(&a->delta_Y0, &b->delta_Y0); + if (ret != 0) { + return ret; + } + + ret = sbp_s32_cmp(&a->delta_Z0, &b->delta_Z0); + if (ret != 0) { + return ret; + } + + ret = sbp_s32_cmp(&a->theta_01, &b->theta_01); + if (ret != 0) { + return ret; + } + + ret = sbp_s32_cmp(&a->theta_02, &b->theta_02); + if (ret != 0) { + return ret; + } + + ret = sbp_s32_cmp(&a->theta_03, &b->theta_03); + if (ret != 0) { + return ret; + } + + ret = sbp_s32_cmp(&a->scale, &b->scale); + if (ret != 0) { + return ret; + } + + ret = sbp_s32_cmp(&a->dot_delta_X0, &b->dot_delta_X0); + if (ret != 0) { + return ret; + } + + ret = sbp_s32_cmp(&a->dot_delta_Y0, &b->dot_delta_Y0); + if (ret != 0) { + return ret; + } + + ret = sbp_s32_cmp(&a->dot_delta_Z0, &b->dot_delta_Z0); + if (ret != 0) { + return ret; + } + + ret = sbp_s32_cmp(&a->dot_theta_01, &b->dot_theta_01); + if (ret != 0) { + return ret; + } + + ret = sbp_s32_cmp(&a->dot_theta_02, &b->dot_theta_02); + if (ret != 0) { + return ret; + } + + ret = sbp_s32_cmp(&a->dot_theta_03, &b->dot_theta_03); + if (ret != 0) { + return ret; + } + + ret = sbp_s16_cmp(&a->dot_scale, &b->dot_scale); + if (ret != 0) { + return ret; + } + return ret; +} diff --git a/c/test/auto_check_sbp_navigation_MsgItrf.c b/c/test/auto_check_sbp_navigation_MsgItrf.c new file mode 100644 index 0000000000..2d5528311b --- /dev/null +++ b/c/test/auto_check_sbp_navigation_MsgItrf.c @@ -0,0 +1,333 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml by generate.py. Do +// not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + sbp_msg_type_t msg_type; + sbp_msg_t msg; + void *context; +} last_msg; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static void *DUMMY_MEMORY_FOR_CALLBACKS = (void *)0xdeadbeef; +static void *DUMMY_MEMORY_FOR_IO = (void *)0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return (s32)real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return (s32)real_n; +} + +static void logging_reset() { memset(&last_msg, 0, sizeof(last_msg)); } + +static void msg_callback(u16 sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.msg_type = msg_type; + last_msg.msg = *msg; + last_msg.context = context; +} + +START_TEST(test_auto_check_sbp_navigation_MsgItrf) { + static sbp_msg_callbacks_node_t n; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_callback_register(&sbp_state, 580, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 68, 2, 66, 0, 124, 1, 2, 102, 111, 111, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 98, 97, 114, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 5, 0, 6, 0, 7, 0, 0, 0, 8, 0, 0, 0, 9, + 0, 0, 0, 10, 0, 0, 0, 11, 0, 0, 0, 12, 0, 0, 0, 13, 0, + 0, 0, 14, 0, 0, 0, 15, 0, 0, 0, 16, 0, 0, 0, 17, 0, 0, + 0, 18, 0, 0, 0, 19, 0, 0, 0, 20, 0, 66, 126, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.itrf.delta_X0 = 7; + + test_msg.itrf.delta_Y0 = 8; + + test_msg.itrf.delta_Z0 = 9; + + test_msg.itrf.dot_delta_X0 = 14; + + test_msg.itrf.dot_delta_Y0 = 15; + + test_msg.itrf.dot_delta_Z0 = 16; + + test_msg.itrf.dot_scale = 20; + + test_msg.itrf.dot_theta_01 = 17; + + test_msg.itrf.dot_theta_02 = 18; + + test_msg.itrf.dot_theta_03 = 19; + + test_msg.itrf.re_t0 = 6; + + test_msg.itrf.scale = 13; + + test_msg.itrf.sin = 4; + + { + const char assign_string[] = { + (char)102, (char)111, (char)111, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0}; + memcpy(test_msg.itrf.sn, assign_string, sizeof(assign_string)); + } + + test_msg.itrf.sn_counter_n = 2; + + test_msg.itrf.ssr_iod = 1; + + test_msg.itrf.theta_01 = 10; + + test_msg.itrf.theta_02 = 11; + + test_msg.itrf.theta_03 = 12; + + { + const char assign_string[] = { + (char)98, (char)97, (char)114, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0}; + memcpy(test_msg.itrf.tn, assign_string, sizeof(assign_string)); + } + + test_msg.itrf.tn_counter_m = 3; + + test_msg.itrf.utn = 5; + + sbp_message_send(&sbp_state, SbpMsgItrf, 66, &test_msg, &dummy_write); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff (expected: %zu, " + "actual: %zu)", + sizeof(encoded_frame), dummy_wr); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + + ck_assert_msg(sbp_message_cmp(SbpMsgItrf, &last_msg.msg, &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg( + last_msg.msg.itrf.delta_X0 == 7, + "incorrect value for last_msg.msg.itrf.delta_X0, expected 7, is %d", + last_msg.msg.itrf.delta_X0); + + ck_assert_msg( + last_msg.msg.itrf.delta_Y0 == 8, + "incorrect value for last_msg.msg.itrf.delta_Y0, expected 8, is %d", + last_msg.msg.itrf.delta_Y0); + + ck_assert_msg( + last_msg.msg.itrf.delta_Z0 == 9, + "incorrect value for last_msg.msg.itrf.delta_Z0, expected 9, is %d", + last_msg.msg.itrf.delta_Z0); + + ck_assert_msg(last_msg.msg.itrf.dot_delta_X0 == 14, + "incorrect value for last_msg.msg.itrf.dot_delta_X0, " + "expected 14, is %d", + last_msg.msg.itrf.dot_delta_X0); + + ck_assert_msg(last_msg.msg.itrf.dot_delta_Y0 == 15, + "incorrect value for last_msg.msg.itrf.dot_delta_Y0, " + "expected 15, is %d", + last_msg.msg.itrf.dot_delta_Y0); + + ck_assert_msg(last_msg.msg.itrf.dot_delta_Z0 == 16, + "incorrect value for last_msg.msg.itrf.dot_delta_Z0, " + "expected 16, is %d", + last_msg.msg.itrf.dot_delta_Z0); + + ck_assert_msg( + last_msg.msg.itrf.dot_scale == 20, + "incorrect value for last_msg.msg.itrf.dot_scale, expected 20, is %d", + last_msg.msg.itrf.dot_scale); + + ck_assert_msg(last_msg.msg.itrf.dot_theta_01 == 17, + "incorrect value for last_msg.msg.itrf.dot_theta_01, " + "expected 17, is %d", + last_msg.msg.itrf.dot_theta_01); + + ck_assert_msg(last_msg.msg.itrf.dot_theta_02 == 18, + "incorrect value for last_msg.msg.itrf.dot_theta_02, " + "expected 18, is %d", + last_msg.msg.itrf.dot_theta_02); + + ck_assert_msg(last_msg.msg.itrf.dot_theta_03 == 19, + "incorrect value for last_msg.msg.itrf.dot_theta_03, " + "expected 19, is %d", + last_msg.msg.itrf.dot_theta_03); + + ck_assert_msg( + last_msg.msg.itrf.re_t0 == 6, + "incorrect value for last_msg.msg.itrf.re_t0, expected 6, is %d", + last_msg.msg.itrf.re_t0); + + ck_assert_msg( + last_msg.msg.itrf.scale == 13, + "incorrect value for last_msg.msg.itrf.scale, expected 13, is %d", + last_msg.msg.itrf.scale); + + ck_assert_msg( + last_msg.msg.itrf.sin == 4, + "incorrect value for last_msg.msg.itrf.sin, expected 4, is %d", + last_msg.msg.itrf.sin); + + { + const char check_string[] = { + (char)102, (char)111, (char)111, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0}; + ck_assert_msg(memcmp(&last_msg.msg.itrf.sn, check_string, + sizeof(check_string)) == 0, + "incorrect value for last_msg.msg.itrf.sn, expected string " + "'%s', is '%s'", + check_string, last_msg.msg.itrf.sn); + } + + ck_assert_msg( + last_msg.msg.itrf.sn_counter_n == 2, + "incorrect value for last_msg.msg.itrf.sn_counter_n, expected 2, is %d", + last_msg.msg.itrf.sn_counter_n); + + ck_assert_msg( + last_msg.msg.itrf.ssr_iod == 1, + "incorrect value for last_msg.msg.itrf.ssr_iod, expected 1, is %d", + last_msg.msg.itrf.ssr_iod); + + ck_assert_msg( + last_msg.msg.itrf.theta_01 == 10, + "incorrect value for last_msg.msg.itrf.theta_01, expected 10, is %d", + last_msg.msg.itrf.theta_01); + + ck_assert_msg( + last_msg.msg.itrf.theta_02 == 11, + "incorrect value for last_msg.msg.itrf.theta_02, expected 11, is %d", + last_msg.msg.itrf.theta_02); + + ck_assert_msg( + last_msg.msg.itrf.theta_03 == 12, + "incorrect value for last_msg.msg.itrf.theta_03, expected 12, is %d", + last_msg.msg.itrf.theta_03); + + { + const char check_string[] = { + (char)98, (char)97, (char)114, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0}; + ck_assert_msg(memcmp(&last_msg.msg.itrf.tn, check_string, + sizeof(check_string)) == 0, + "incorrect value for last_msg.msg.itrf.tn, expected string " + "'%s', is '%s'", + check_string, last_msg.msg.itrf.tn); + } + + ck_assert_msg( + last_msg.msg.itrf.tn_counter_m == 3, + "incorrect value for last_msg.msg.itrf.tn_counter_m, expected 3, is %d", + last_msg.msg.itrf.tn_counter_m); + + ck_assert_msg( + last_msg.msg.itrf.utn == 5, + "incorrect value for last_msg.msg.itrf.utn, expected 5, is %d", + last_msg.msg.itrf.utn); + } +} +END_TEST + +Suite *auto_check_sbp_navigation_MsgItrf_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: auto_check_sbp_navigation_MsgItrf"); + TCase *tc_acq = + tcase_create("Automated_Suite_auto_check_sbp_navigation_MsgItrf"); + tcase_add_test(tc_acq, test_auto_check_sbp_navigation_MsgItrf); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/check_main.c b/c/test/check_main.c index 3ea32395ab..bc6b9af02a 100644 --- a/c/test/check_main.c +++ b/c/test/check_main.c @@ -57,6 +57,7 @@ int main(void) { srunner_add_suite(sr, auto_check_sbp_navigation_MsgGPSTime_suite()); srunner_add_suite(sr, auto_check_sbp_navigation_MsgGPSTimeDepA_suite()); srunner_add_suite(sr, auto_check_sbp_navigation_MsgGPSTimeGNSS_suite()); + srunner_add_suite(sr, auto_check_sbp_navigation_MsgItrf_suite()); srunner_add_suite(sr, auto_check_sbp_navigation_MsgPosECEF_suite()); srunner_add_suite(sr, auto_check_sbp_navigation_MsgPosECEFCov_suite()); srunner_add_suite(sr, auto_check_sbp_navigation_MsgPosECEFCovGNSS_suite()); diff --git a/c/test/check_main_legacy.c b/c/test/check_main_legacy.c index 461d1dff7e..e8c4f330c4 100644 --- a/c/test/check_main_legacy.c +++ b/c/test/check_main_legacy.c @@ -71,6 +71,7 @@ int main(void) { legacy_auto_check_sbp_navigation_MsgGPSTimeDepA_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_navigation_MsgGPSTimeGNSS_suite()); + srunner_add_suite(sr, legacy_auto_check_sbp_navigation_MsgItrf_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_navigation_MsgPosECEF_suite()); srunner_add_suite(sr, legacy_auto_check_sbp_navigation_MsgPosECEFCov_suite()); srunner_add_suite(sr, diff --git a/c/test/check_suites.h b/c/test/check_suites.h index d07ef70412..6d3bf7dc18 100644 --- a/c/test/check_suites.h +++ b/c/test/check_suites.h @@ -45,6 +45,7 @@ Suite* auto_check_sbp_navigation_MsgDopsDepA_suite(void); Suite* auto_check_sbp_navigation_MsgGPSTime_suite(void); Suite* auto_check_sbp_navigation_MsgGPSTimeDepA_suite(void); Suite* auto_check_sbp_navigation_MsgGPSTimeGNSS_suite(void); +Suite* auto_check_sbp_navigation_MsgItrf_suite(void); Suite* auto_check_sbp_navigation_MsgPosECEF_suite(void); Suite* auto_check_sbp_navigation_MsgPosECEFCov_suite(void); Suite* auto_check_sbp_navigation_MsgPosECEFCovGNSS_suite(void); diff --git a/c/test/check_suites_legacy.h b/c/test/check_suites_legacy.h index 421c8292e1..2991203bd5 100644 --- a/c/test/check_suites_legacy.h +++ b/c/test/check_suites_legacy.h @@ -46,6 +46,7 @@ Suite* legacy_auto_check_sbp_navigation_MsgDopsDepA_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgGPSTime_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgGPSTimeDepA_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgGPSTimeGNSS_suite(void); +Suite* legacy_auto_check_sbp_navigation_MsgItrf_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgPosECEF_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgPosECEFCov_suite(void); Suite* legacy_auto_check_sbp_navigation_MsgPosECEFCovGNSS_suite(void); diff --git a/c/test/cpp/auto_check_sbp_navigation_MsgItrf.cc b/c/test/cpp/auto_check_sbp_navigation_MsgItrf.cc new file mode 100644 index 0000000000..93feadcdcd --- /dev/null +++ b/c/test/cpp/auto_check_sbp_navigation_MsgItrf.cc @@ -0,0 +1,220 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml by generate.py. Do +// not modify by hand! + +#include +#include +#include +#include +#include +class Test_auto_check_sbp_navigation_MsgItrf0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::MessageHandler { + public: + Test_auto_check_sbp_navigation_MsgItrf0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::MessageHandler(this), + last_msg_(), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, const sbp_msg_itrf_t &msg) override { + last_msg_ = msg; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + sbp_msg_itrf_t last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_auto_check_sbp_navigation_MsgItrf0, Test) { + uint8_t encoded_frame[] = { + 85, 68, 2, 66, 0, 124, 1, 2, 102, 111, 111, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 98, 97, 114, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 5, 0, 6, 0, 7, 0, 0, 0, 8, 0, 0, 0, 9, + 0, 0, 0, 10, 0, 0, 0, 11, 0, 0, 0, 12, 0, 0, 0, 13, 0, + 0, 0, 14, 0, 0, 0, 15, 0, 0, 0, 16, 0, 0, 0, 17, 0, 0, + 0, 18, 0, 0, 0, 19, 0, 0, 0, 20, 0, 66, 126, + }; + + sbp_msg_itrf_t test_msg{}; + test_msg.delta_X0 = 7; + test_msg.delta_Y0 = 8; + test_msg.delta_Z0 = 9; + test_msg.dot_delta_X0 = 14; + test_msg.dot_delta_Y0 = 15; + test_msg.dot_delta_Z0 = 16; + test_msg.dot_scale = 20; + test_msg.dot_theta_01 = 17; + test_msg.dot_theta_02 = 18; + test_msg.dot_theta_03 = 19; + test_msg.re_t0 = 6; + test_msg.scale = 13; + test_msg.sin = 4; + { + const char assign_string[] = { + (char)102, (char)111, (char)111, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0}; + memcpy(test_msg.sn, assign_string, sizeof(assign_string)); + } + test_msg.sn_counter_n = 2; + test_msg.ssr_iod = 1; + test_msg.theta_01 = 10; + test_msg.theta_02 = 11; + test_msg.theta_03 = 12; + { + const char assign_string[] = { + (char)98, (char)97, (char)114, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0}; + memcpy(test_msg.tn, assign_string, sizeof(assign_string)); + } + test_msg.tn_counter_m = 3; + test_msg.utn = 5; + + 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_.delta_X0, 7) + << "incorrect value for last_msg_.delta_X0, expected 7, is " + << last_msg_.delta_X0; + EXPECT_EQ(last_msg_.delta_Y0, 8) + << "incorrect value for last_msg_.delta_Y0, expected 8, is " + << last_msg_.delta_Y0; + EXPECT_EQ(last_msg_.delta_Z0, 9) + << "incorrect value for last_msg_.delta_Z0, expected 9, is " + << last_msg_.delta_Z0; + EXPECT_EQ(last_msg_.dot_delta_X0, 14) + << "incorrect value for last_msg_.dot_delta_X0, expected 14, is " + << last_msg_.dot_delta_X0; + EXPECT_EQ(last_msg_.dot_delta_Y0, 15) + << "incorrect value for last_msg_.dot_delta_Y0, expected 15, is " + << last_msg_.dot_delta_Y0; + EXPECT_EQ(last_msg_.dot_delta_Z0, 16) + << "incorrect value for last_msg_.dot_delta_Z0, expected 16, is " + << last_msg_.dot_delta_Z0; + EXPECT_EQ(last_msg_.dot_scale, 20) + << "incorrect value for last_msg_.dot_scale, expected 20, is " + << last_msg_.dot_scale; + EXPECT_EQ(last_msg_.dot_theta_01, 17) + << "incorrect value for last_msg_.dot_theta_01, expected 17, is " + << last_msg_.dot_theta_01; + EXPECT_EQ(last_msg_.dot_theta_02, 18) + << "incorrect value for last_msg_.dot_theta_02, expected 18, is " + << last_msg_.dot_theta_02; + EXPECT_EQ(last_msg_.dot_theta_03, 19) + << "incorrect value for last_msg_.dot_theta_03, expected 19, is " + << last_msg_.dot_theta_03; + EXPECT_EQ(last_msg_.re_t0, 6) + << "incorrect value for last_msg_.re_t0, expected 6, is " + << last_msg_.re_t0; + EXPECT_EQ(last_msg_.scale, 13) + << "incorrect value for last_msg_.scale, expected 13, is " + << last_msg_.scale; + EXPECT_EQ(last_msg_.sin, 4) + << "incorrect value for last_msg_.sin, expected 4, is " << last_msg_.sin; + { + const char check_string[] = { + (char)102, (char)111, (char)111, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0}; + EXPECT_EQ(memcmp(last_msg_.sn, check_string, sizeof(check_string)), 0) + << "incorrect value for last_msg_.sn, expected string '" << check_string + << "', is '" << last_msg_.sn << "'"; + } + EXPECT_EQ(last_msg_.sn_counter_n, 2) + << "incorrect value for last_msg_.sn_counter_n, expected 2, is " + << last_msg_.sn_counter_n; + EXPECT_EQ(last_msg_.ssr_iod, 1) + << "incorrect value for last_msg_.ssr_iod, expected 1, is " + << last_msg_.ssr_iod; + EXPECT_EQ(last_msg_.theta_01, 10) + << "incorrect value for last_msg_.theta_01, expected 10, is " + << last_msg_.theta_01; + EXPECT_EQ(last_msg_.theta_02, 11) + << "incorrect value for last_msg_.theta_02, expected 11, is " + << last_msg_.theta_02; + EXPECT_EQ(last_msg_.theta_03, 12) + << "incorrect value for last_msg_.theta_03, expected 12, is " + << last_msg_.theta_03; + { + const char check_string[] = { + (char)98, (char)97, (char)114, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0}; + EXPECT_EQ(memcmp(last_msg_.tn, check_string, sizeof(check_string)), 0) + << "incorrect value for last_msg_.tn, expected string '" << check_string + << "', is '" << last_msg_.tn << "'"; + } + EXPECT_EQ(last_msg_.tn_counter_m, 3) + << "incorrect value for last_msg_.tn_counter_m, expected 3, is " + << last_msg_.tn_counter_m; + EXPECT_EQ(last_msg_.utn, 5) + << "incorrect value for last_msg_.utn, expected 5, is " << last_msg_.utn; +} diff --git a/c/test/legacy/auto_check_sbp_navigation_MsgItrf.c b/c/test/legacy/auto_check_sbp_navigation_MsgItrf.c new file mode 100644 index 0000000000..e2e98064fd --- /dev/null +++ b/c/test/legacy/auto_check_sbp_navigation_MsgItrf.c @@ -0,0 +1,334 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml by generate.py. Do +// not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u8 len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + void *context; +} last_msg; + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + u16 msg_type; + u8 msg_len; + u8 msg[SBP_MAX_PAYLOAD_LEN]; + u16 frame_len; + u8 frame[SBP_MAX_FRAME_LEN]; + void *context; +} last_frame; + +static u32 dummy_wr = 0; +static u32 dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static int DUMMY_MEMORY_FOR_CALLBACKS = 0xdeadbeef; +static int DUMMY_MEMORY_FOR_IO = 0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + u32 real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return real_n; +} + +static void logging_reset() { + memset(&last_msg, 0, sizeof(last_msg)); + memset(&last_frame, 0, sizeof(last_frame)); +} + +static void msg_callback(u16 sender_id, u8 len, u8 msg[], void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.len = len; + last_msg.context = context; + memcpy(last_msg.msg, msg, len); +} + +static void frame_callback(u16 sender_id, u16 msg_type, u8 msg_len, u8 msg[], + u16 frame_len, u8 frame[], void *context) { + last_frame.n_callbacks_logged++; + last_frame.sender_id = sender_id; + last_frame.msg_type = msg_type; + last_frame.msg_len = msg_len; + memcpy(last_frame.msg, msg, msg_len); + last_frame.frame_len = frame_len; + memcpy(last_frame.frame, frame, frame_len); + last_frame.context = context; +} + +START_TEST(test_legacy_auto_check_sbp_navigation_MsgItrf) { + static sbp_msg_callbacks_node_t n; + static sbp_msg_callbacks_node_t n2; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_payload_callback_register(&sbp_state, 580, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + sbp_frame_callback_register(&sbp_state, 580, &frame_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n2); + + u8 encoded_frame[] = { + 85, 68, 2, 66, 0, 124, 1, 2, 102, 111, 111, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 98, 97, 114, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 5, 0, 6, 0, 7, 0, 0, 0, 8, 0, 0, 0, 9, + 0, 0, 0, 10, 0, 0, 0, 11, 0, 0, 0, 12, 0, 0, 0, 13, 0, + 0, 0, 14, 0, 0, 0, 15, 0, 0, 0, 16, 0, 0, 0, 17, 0, 0, + 0, 18, 0, 0, 0, 19, 0, 0, 0, 20, 0, 66, 126, + }; + + dummy_reset(); + + u8 test_msg_storage[SBP_MAX_PAYLOAD_LEN]; + memset(test_msg_storage, 0, sizeof(test_msg_storage)); + u8 test_msg_len = 0; + msg_itrf_t *test_msg = (msg_itrf_t *)test_msg_storage; + test_msg_len = sizeof(*test_msg); + test_msg->delta_X0 = 7; + test_msg->delta_Y0 = 8; + test_msg->delta_Z0 = 9; + test_msg->dot_delta_X0 = 14; + test_msg->dot_delta_Y0 = 15; + test_msg->dot_delta_Z0 = 16; + test_msg->dot_scale = 20; + test_msg->dot_theta_01 = 17; + test_msg->dot_theta_02 = 18; + test_msg->dot_theta_03 = 19; + test_msg->re_t0 = 6; + test_msg->scale = 13; + test_msg->sin = 4; + { + const char assign_string[] = { + (char)102, (char)111, (char)111, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0}; + memcpy(test_msg->sn, assign_string, sizeof(assign_string)); + if (sizeof(test_msg->sn) == 0) { + test_msg_len += sizeof(assign_string); + } + } + test_msg->sn_counter_n = 2; + test_msg->ssr_iod = 1; + test_msg->theta_01 = 10; + test_msg->theta_02 = 11; + test_msg->theta_03 = 12; + { + const char assign_string[] = { + (char)98, (char)97, (char)114, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0}; + memcpy(test_msg->tn, assign_string, sizeof(assign_string)); + if (sizeof(test_msg->tn) == 0) { + test_msg_len += sizeof(assign_string); + } + } + test_msg->tn_counter_m = 3; + test_msg->utn = 5; + sbp_payload_send(&sbp_state, 580, 66, test_msg_len, test_msg_storage, + &dummy_write); + + ck_assert_msg( + test_msg_len == sizeof(encoded_frame) - 8, + "Test message has not been generated correctly, or the encoded frame " + "from the spec is badly defined. Check your test spec"); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff"); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_msg.len == sizeof(encoded_frame) - 8, + "msg_callback: len decoded incorrectly"); + ck_assert_msg( + memcmp(last_msg.msg, encoded_frame + 6, sizeof(encoded_frame) - 8) == 0, + "msg_callback: test data decoded incorrectly"); + ck_assert_msg(last_msg.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + ck_assert_msg(last_frame.n_callbacks_logged == 1, + "frame_callback: one callback should have been logged"); + ck_assert_msg(last_frame.sender_id == 66, + "frame_callback: sender_id decoded incorrectly"); + ck_assert_msg(last_frame.msg_type == 580, + "frame_callback: msg_type decoded incorrectly"); + ck_assert_msg(last_frame.msg_len == sizeof(encoded_frame) - 8, + "frame_callback: msg_len decoded incorrectly"); + ck_assert_msg(memcmp(last_frame.msg, encoded_frame + 6, + sizeof(encoded_frame) - 8) == 0, + "frame_callback: test data decoded incorrectly"); + ck_assert_msg(last_frame.frame_len == sizeof(encoded_frame), + "frame_callback: frame_len decoded incorrectly"); + ck_assert_msg( + memcmp(last_frame.frame, encoded_frame, sizeof(encoded_frame)) == 0, + "frame_callback: frame decoded incorrectly"); + ck_assert_msg(last_frame.context == &DUMMY_MEMORY_FOR_CALLBACKS, + "frame_callback: context pointer incorrectly passed"); + + // Cast to expected message type - the +6 byte offset is where the payload + // starts + msg_itrf_t *check_msg = (msg_itrf_t *)((void *)last_msg.msg); + // Run tests against fields + ck_assert_msg(check_msg != 0, "stub to prevent warnings if msg isn't used"); + ck_assert_msg(check_msg->delta_X0 == 7, + "incorrect value for delta_X0, expected 7, is %d", + check_msg->delta_X0); + ck_assert_msg(check_msg->delta_Y0 == 8, + "incorrect value for delta_Y0, expected 8, is %d", + check_msg->delta_Y0); + ck_assert_msg(check_msg->delta_Z0 == 9, + "incorrect value for delta_Z0, expected 9, is %d", + check_msg->delta_Z0); + ck_assert_msg(check_msg->dot_delta_X0 == 14, + "incorrect value for dot_delta_X0, expected 14, is %d", + check_msg->dot_delta_X0); + ck_assert_msg(check_msg->dot_delta_Y0 == 15, + "incorrect value for dot_delta_Y0, expected 15, is %d", + check_msg->dot_delta_Y0); + ck_assert_msg(check_msg->dot_delta_Z0 == 16, + "incorrect value for dot_delta_Z0, expected 16, is %d", + check_msg->dot_delta_Z0); + ck_assert_msg(check_msg->dot_scale == 20, + "incorrect value for dot_scale, expected 20, is %d", + check_msg->dot_scale); + ck_assert_msg(check_msg->dot_theta_01 == 17, + "incorrect value for dot_theta_01, expected 17, is %d", + check_msg->dot_theta_01); + ck_assert_msg(check_msg->dot_theta_02 == 18, + "incorrect value for dot_theta_02, expected 18, is %d", + check_msg->dot_theta_02); + ck_assert_msg(check_msg->dot_theta_03 == 19, + "incorrect value for dot_theta_03, expected 19, is %d", + check_msg->dot_theta_03); + ck_assert_msg(check_msg->re_t0 == 6, + "incorrect value for re_t0, expected 6, is %d", + check_msg->re_t0); + ck_assert_msg(check_msg->scale == 13, + "incorrect value for scale, expected 13, is %d", + check_msg->scale); + ck_assert_msg(check_msg->sin == 4, + "incorrect value for sin, expected 4, is %d", check_msg->sin); + { + const char check_string[] = { + (char)102, (char)111, (char)111, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0}; + ck_assert_msg( + memcmp(check_msg->sn, check_string, sizeof(check_string)) == 0, + "incorrect value for check_msg->sn, expected string '%s', is '%s'", + check_string, check_msg->sn); + } + ck_assert_msg(check_msg->sn_counter_n == 2, + "incorrect value for sn_counter_n, expected 2, is %d", + check_msg->sn_counter_n); + ck_assert_msg(check_msg->ssr_iod == 1, + "incorrect value for ssr_iod, expected 1, is %d", + check_msg->ssr_iod); + ck_assert_msg(check_msg->theta_01 == 10, + "incorrect value for theta_01, expected 10, is %d", + check_msg->theta_01); + ck_assert_msg(check_msg->theta_02 == 11, + "incorrect value for theta_02, expected 11, is %d", + check_msg->theta_02); + ck_assert_msg(check_msg->theta_03 == 12, + "incorrect value for theta_03, expected 12, is %d", + check_msg->theta_03); + { + const char check_string[] = { + (char)98, (char)97, (char)114, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0}; + ck_assert_msg( + memcmp(check_msg->tn, check_string, sizeof(check_string)) == 0, + "incorrect value for check_msg->tn, expected string '%s', is '%s'", + check_string, check_msg->tn); + } + ck_assert_msg(check_msg->tn_counter_m == 3, + "incorrect value for tn_counter_m, expected 3, is %d", + check_msg->tn_counter_m); + ck_assert_msg(check_msg->utn == 5, + "incorrect value for utn, expected 5, is %d", check_msg->utn); + } +} +END_TEST + +Suite *legacy_auto_check_sbp_navigation_MsgItrf_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: legacy_auto_check_sbp_navigation_MsgItrf"); + TCase *tc_acq = + tcase_create("Automated_Suite_legacy_auto_check_sbp_navigation_MsgItrf"); + tcase_add_test(tc_acq, test_legacy_auto_check_sbp_navigation_MsgItrf); + suite_add_tcase(s, tc_acq); + return s; +} \ No newline at end of file diff --git a/c/test/legacy/cpp/auto_check_sbp_navigation_MsgItrf.cc b/c/test/legacy/cpp/auto_check_sbp_navigation_MsgItrf.cc new file mode 100644 index 0000000000..584d12a706 --- /dev/null +++ b/c/test/legacy/cpp/auto_check_sbp_navigation_MsgItrf.cc @@ -0,0 +1,226 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml by generate.py. Do +// not modify by hand! + +#include +#include +#include +#include +class Test_legacy_auto_check_sbp_navigation_MsgItrf0 + : public ::testing::Test, + public sbp::State, + public sbp::IReader, + public sbp::IWriter, + sbp::PayloadHandler { + public: + Test_legacy_auto_check_sbp_navigation_MsgItrf0() + : ::testing::Test(), + sbp::State(), + sbp::IReader(), + sbp::IWriter(), + sbp::PayloadHandler(this), + last_msg_storage_(), + last_msg_(reinterpret_cast(last_msg_storage_)), + last_msg_len_(), + last_sender_id_(), + n_callbacks_logged_(), + dummy_wr_(), + dummy_rd_(), + dummy_buff_() { + set_reader(this); + set_writer(this); + } + + s32 read(uint8_t *buf, const uint32_t n) override { + uint32_t real_n = n; + memcpy(buf, dummy_buff_ + dummy_rd_, real_n); + dummy_rd_ += real_n; + return (s32)real_n; + } + + s32 write(const uint8_t *buf, uint32_t n) override { + uint32_t real_n = n; + memcpy(dummy_buff_ + dummy_wr_, buf, real_n); + dummy_wr_ += real_n; + return (s32)real_n; + } + + protected: + void handle_sbp_msg(uint16_t sender_id, uint8_t message_length, + const msg_itrf_t &msg) override { + memcpy(last_msg_storage_, &msg, message_length); + last_msg_len_ = message_length; + last_sender_id_ = sender_id; + n_callbacks_logged_++; + } + + uint8_t last_msg_storage_[SBP_MAX_PAYLOAD_LEN]; + msg_itrf_t *last_msg_; + uint8_t last_msg_len_; + uint16_t last_sender_id_; + size_t n_callbacks_logged_; + uint32_t dummy_wr_; + uint32_t dummy_rd_; + uint8_t dummy_buff_[1024]; +}; + +TEST_F(Test_legacy_auto_check_sbp_navigation_MsgItrf0, Test) { + uint8_t encoded_frame[] = { + 85, 68, 2, 66, 0, 124, 1, 2, 102, 111, 111, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 98, 97, 114, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 5, 0, 6, 0, 7, 0, 0, 0, 8, 0, 0, 0, 9, + 0, 0, 0, 10, 0, 0, 0, 11, 0, 0, 0, 12, 0, 0, 0, 13, 0, + 0, 0, 14, 0, 0, 0, 15, 0, 0, 0, 16, 0, 0, 0, 17, 0, 0, + 0, 18, 0, 0, 0, 19, 0, 0, 0, 20, 0, 66, 126, + }; + + uint8_t test_msg_storage[SBP_MAX_PAYLOAD_LEN]{}; + uint8_t test_msg_len = 0; + msg_itrf_t *test_msg = (msg_itrf_t *)test_msg_storage; + test_msg_len = (uint8_t)sizeof(*test_msg); + test_msg->delta_X0 = 7; + test_msg->delta_Y0 = 8; + test_msg->delta_Z0 = 9; + test_msg->dot_delta_X0 = 14; + test_msg->dot_delta_Y0 = 15; + test_msg->dot_delta_Z0 = 16; + test_msg->dot_scale = 20; + test_msg->dot_theta_01 = 17; + test_msg->dot_theta_02 = 18; + test_msg->dot_theta_03 = 19; + test_msg->re_t0 = 6; + test_msg->scale = 13; + test_msg->sin = 4; + { + const char assign_string[] = { + (char)102, (char)111, (char)111, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0}; + memcpy(test_msg->sn, assign_string, sizeof(assign_string)); + if (sizeof(test_msg->sn) == 0) { + test_msg_len = (uint8_t)(test_msg_len + sizeof(assign_string)); + } + } + test_msg->sn_counter_n = 2; + test_msg->ssr_iod = 1; + test_msg->theta_01 = 10; + test_msg->theta_02 = 11; + test_msg->theta_03 = 12; + { + const char assign_string[] = { + (char)98, (char)97, (char)114, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0}; + memcpy(test_msg->tn, assign_string, sizeof(assign_string)); + if (sizeof(test_msg->tn) == 0) { + test_msg_len = (uint8_t)(test_msg_len + sizeof(assign_string)); + } + } + test_msg->tn_counter_m = 3; + test_msg->utn = 5; + + EXPECT_EQ(send_message(580, 66, test_msg_len, test_msg_storage), SBP_OK); + + EXPECT_EQ(dummy_wr_, sizeof(encoded_frame)); + EXPECT_EQ(memcmp(dummy_buff_, encoded_frame, sizeof(encoded_frame)), 0); + + while (dummy_rd_ < dummy_wr_) { + process(); + } + + EXPECT_EQ(n_callbacks_logged_, 1); + EXPECT_EQ(last_sender_id_, 66); + EXPECT_EQ(last_msg_len_, test_msg_len); + EXPECT_EQ(last_msg_->delta_X0, 7) + << "incorrect value for delta_X0, expected 7, is " << last_msg_->delta_X0; + EXPECT_EQ(last_msg_->delta_Y0, 8) + << "incorrect value for delta_Y0, expected 8, is " << last_msg_->delta_Y0; + EXPECT_EQ(last_msg_->delta_Z0, 9) + << "incorrect value for delta_Z0, expected 9, is " << last_msg_->delta_Z0; + EXPECT_EQ(last_msg_->dot_delta_X0, 14) + << "incorrect value for dot_delta_X0, expected 14, is " + << last_msg_->dot_delta_X0; + EXPECT_EQ(last_msg_->dot_delta_Y0, 15) + << "incorrect value for dot_delta_Y0, expected 15, is " + << last_msg_->dot_delta_Y0; + EXPECT_EQ(last_msg_->dot_delta_Z0, 16) + << "incorrect value for dot_delta_Z0, expected 16, is " + << last_msg_->dot_delta_Z0; + EXPECT_EQ(last_msg_->dot_scale, 20) + << "incorrect value for dot_scale, expected 20, is " + << last_msg_->dot_scale; + EXPECT_EQ(last_msg_->dot_theta_01, 17) + << "incorrect value for dot_theta_01, expected 17, is " + << last_msg_->dot_theta_01; + EXPECT_EQ(last_msg_->dot_theta_02, 18) + << "incorrect value for dot_theta_02, expected 18, is " + << last_msg_->dot_theta_02; + EXPECT_EQ(last_msg_->dot_theta_03, 19) + << "incorrect value for dot_theta_03, expected 19, is " + << last_msg_->dot_theta_03; + EXPECT_EQ(last_msg_->re_t0, 6) + << "incorrect value for re_t0, expected 6, is " << last_msg_->re_t0; + EXPECT_EQ(last_msg_->scale, 13) + << "incorrect value for scale, expected 13, is " << last_msg_->scale; + EXPECT_EQ(last_msg_->sin, 4) + << "incorrect value for sin, expected 4, is " << last_msg_->sin; + { + const char check_string[] = { + (char)102, (char)111, (char)111, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0}; + EXPECT_EQ(memcmp(last_msg_->sn, check_string, sizeof(check_string)), 0) + << "incorrect value for last_msg_->sn, expected string '" + << check_string << "', is '" << last_msg_->sn << "'"; + } + EXPECT_EQ(last_msg_->sn_counter_n, 2) + << "incorrect value for sn_counter_n, expected 2, is " + << last_msg_->sn_counter_n; + EXPECT_EQ(last_msg_->ssr_iod, 1) + << "incorrect value for ssr_iod, expected 1, is " << last_msg_->ssr_iod; + EXPECT_EQ(last_msg_->theta_01, 10) + << "incorrect value for theta_01, expected 10, is " + << last_msg_->theta_01; + EXPECT_EQ(last_msg_->theta_02, 11) + << "incorrect value for theta_02, expected 11, is " + << last_msg_->theta_02; + EXPECT_EQ(last_msg_->theta_03, 12) + << "incorrect value for theta_03, expected 12, is " + << last_msg_->theta_03; + { + const char check_string[] = { + (char)98, (char)97, (char)114, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, (char)0, + (char)0, (char)0, (char)0}; + EXPECT_EQ(memcmp(last_msg_->tn, check_string, sizeof(check_string)), 0) + << "incorrect value for last_msg_->tn, expected string '" + << check_string << "', is '" << last_msg_->tn << "'"; + } + EXPECT_EQ(last_msg_->tn_counter_m, 3) + << "incorrect value for tn_counter_m, expected 3, is " + << last_msg_->tn_counter_m; + EXPECT_EQ(last_msg_->utn, 5) + << "incorrect value for utn, expected 5, is " << last_msg_->utn; +} diff --git a/docs/sbp.pdf b/docs/sbp.pdf index 211429856b0c77b60338462e722c6cb8e3c6d58e..2708a03b8e2a515433a284dada5b05359380ae0b 100644 GIT binary patch delta 94468 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 B7xDlA delta 100130 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νWz1(}-~+OFzw5o!JUcw?z$x;TU$bQ# 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 Pocx?9w6szx(kTA}^yp3y diff --git a/haskell/src/SwiftNav/SBP/Msg.hs b/haskell/src/SwiftNav/SBP/Msg.hs index 873cebec31..ce5d145329 100644 --- a/haskell/src/SwiftNav/SBP/Msg.hs +++ b/haskell/src/SwiftNav/SBP/Msg.hs @@ -147,6 +147,7 @@ data SBPMsg = | SBPMsgInsStatus MsgInsStatus Msg | SBPMsgInsUpdates MsgInsUpdates Msg | SBPMsgIono MsgIono Msg + | SBPMsgItrf MsgItrf Msg | SBPMsgLinuxCpuState MsgLinuxCpuState Msg | SBPMsgLinuxCpuStateDepA MsgLinuxCpuStateDepA Msg | SBPMsgLinuxMemState MsgLinuxMemState Msg @@ -377,6 +378,7 @@ instance Binary SBPMsg where | _msgSBPType == msgInsStatus = SBPMsgInsStatus (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgInsUpdates = SBPMsgInsUpdates (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgIono = SBPMsgIono (decode (fromStrict (unBytes _msgSBPPayload))) m + | _msgSBPType == msgItrf = SBPMsgItrf (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgLinuxCpuState = SBPMsgLinuxCpuState (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgLinuxCpuStateDepA = SBPMsgLinuxCpuStateDepA (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgLinuxMemState = SBPMsgLinuxMemState (decode (fromStrict (unBytes _msgSBPPayload))) m @@ -599,6 +601,7 @@ instance Binary SBPMsg where encoder (SBPMsgInsStatus _ m) = put m encoder (SBPMsgInsUpdates _ m) = put m encoder (SBPMsgIono _ m) = put m + encoder (SBPMsgItrf _ m) = put m encoder (SBPMsgLinuxCpuState _ m) = put m encoder (SBPMsgLinuxCpuStateDepA _ m) = put m encoder (SBPMsgLinuxMemState _ m) = put m @@ -825,6 +828,7 @@ instance FromJSON SBPMsg where | msgType == msgInsStatus = SBPMsgInsStatus <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgInsUpdates = SBPMsgInsUpdates <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgIono = SBPMsgIono <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgItrf = SBPMsgItrf <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgLinuxCpuState = SBPMsgLinuxCpuState <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgLinuxCpuStateDepA = SBPMsgLinuxCpuStateDepA <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgLinuxMemState = SBPMsgLinuxMemState <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj @@ -1052,6 +1056,7 @@ instance ToJSON SBPMsg where toJSON (SBPMsgInsStatus n m) = toJSON n <<>> toJSON m toJSON (SBPMsgInsUpdates n m) = toJSON n <<>> toJSON m toJSON (SBPMsgIono n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgItrf n m) = toJSON n <<>> toJSON m toJSON (SBPMsgLinuxCpuState n m) = toJSON n <<>> toJSON m toJSON (SBPMsgLinuxCpuStateDepA n m) = toJSON n <<>> toJSON m toJSON (SBPMsgLinuxMemState n m) = toJSON n <<>> toJSON m @@ -1273,6 +1278,7 @@ instance HasMsg SBPMsg where msg f (SBPMsgInsStatus n m) = SBPMsgInsStatus n <$> f m msg f (SBPMsgInsUpdates n m) = SBPMsgInsUpdates n <$> f m msg f (SBPMsgIono n m) = SBPMsgIono n <$> f m + msg f (SBPMsgItrf n m) = SBPMsgItrf n <$> f m msg f (SBPMsgLinuxCpuState n m) = SBPMsgLinuxCpuState n <$> f m msg f (SBPMsgLinuxCpuStateDepA n m) = SBPMsgLinuxCpuStateDepA n <$> f m msg f (SBPMsgLinuxMemState n m) = SBPMsgLinuxMemState n <$> f m diff --git a/haskell/src/SwiftNav/SBP/Navigation.hs b/haskell/src/SwiftNav/SBP/Navigation.hs index b32d086ed9..63b431f8fb 100644 --- a/haskell/src/SwiftNav/SBP/Navigation.hs +++ b/haskell/src/SwiftNav/SBP/Navigation.hs @@ -2303,3 +2303,108 @@ instance Binary MsgProtectionLevel where $(makeSBP 'msgProtectionLevel ''MsgProtectionLevel) $(makeJSON "_msgProtectionLevel_" ''MsgProtectionLevel) $(makeLenses ''MsgProtectionLevel) + +msgItrf :: Word16 +msgItrf = 0x0244 + +data MsgItrf = MsgItrf + { _msgItrf_ssr_iod :: !Word8 + -- ^ SSR IOD parameter. + , _msgItrf_sn_counter_n :: !Word8 + -- ^ Source-Name Counter N. + , _msgItrf_sn :: !Text + -- ^ Source-Name + , _msgItrf_tn_counter_m :: !Word8 + -- ^ Target-Name Counter M. + , _msgItrf_tn :: !Text + -- ^ Target-Name + , _msgItrf_sin :: !Word8 + -- ^ System Identification Number. + , _msgItrf_utn :: !Word16 + -- ^ Utilized Transformation Message. + , _msgItrf_re_t0 :: !Word16 + -- ^ Reference Epoch t0 for transformation parameter set given as Modified + -- Julian Day (MDJ) Number minus 44244 days. + , _msgItrf_delta_X0 :: !Int32 + -- ^ Translation in X for Reference Epoch t0. + , _msgItrf_delta_Y0 :: !Int32 + -- ^ Translation in Y for Reference Epoch t0. + , _msgItrf_delta_Z0 :: !Int32 + -- ^ Translation in Z for Reference Epoch t0. + , _msgItrf_theta_01 :: !Int32 + -- ^ Rotation around the X-axis for Reference Epoch t0. + , _msgItrf_theta_02 :: !Int32 + -- ^ Rotation around the Y-axis for Reference Epoch t0. + , _msgItrf_theta_03 :: !Int32 + -- ^ Rotation around the Z-axis for Reference Epoch t0. + , _msgItrf_scale :: !Int32 + -- ^ Scale correction for Reference Epoch t0. + , _msgItrf_dot_delta_X0 :: !Int32 + -- ^ Rate of change of translation in X. + , _msgItrf_dot_delta_Y0 :: !Int32 + -- ^ Rate of change of translation in Y. + , _msgItrf_dot_delta_Z0 :: !Int32 + -- ^ Rate of change of translation in Z. + , _msgItrf_dot_theta_01 :: !Int32 + -- ^ Rate of change of rotation around the X-axis. + , _msgItrf_dot_theta_02 :: !Int32 + -- ^ Rate of change of rotation around the Y-axis. + , _msgItrf_dot_theta_03 :: !Int32 + -- ^ Rate of change of rotation around the Z-axis. + , _msgItrf_dot_scale :: !Int16 + -- ^ Rate of change of scale correction. + } deriving ( Show, Read, Eq ) + +instance Binary MsgItrf where + get = do + _msgItrf_ssr_iod <- getWord8 + _msgItrf_sn_counter_n <- getWord8 + _msgItrf_sn <- decodeUtf8 <$> getByteString 31 + _msgItrf_tn_counter_m <- getWord8 + _msgItrf_tn <- decodeUtf8 <$> getByteString 31 + _msgItrf_sin <- getWord8 + _msgItrf_utn <- getWord16le + _msgItrf_re_t0 <- getWord16le + _msgItrf_delta_X0 <- (fromIntegral <$> getWord32le) + _msgItrf_delta_Y0 <- (fromIntegral <$> getWord32le) + _msgItrf_delta_Z0 <- (fromIntegral <$> getWord32le) + _msgItrf_theta_01 <- (fromIntegral <$> getWord32le) + _msgItrf_theta_02 <- (fromIntegral <$> getWord32le) + _msgItrf_theta_03 <- (fromIntegral <$> getWord32le) + _msgItrf_scale <- (fromIntegral <$> getWord32le) + _msgItrf_dot_delta_X0 <- (fromIntegral <$> getWord32le) + _msgItrf_dot_delta_Y0 <- (fromIntegral <$> getWord32le) + _msgItrf_dot_delta_Z0 <- (fromIntegral <$> getWord32le) + _msgItrf_dot_theta_01 <- (fromIntegral <$> getWord32le) + _msgItrf_dot_theta_02 <- (fromIntegral <$> getWord32le) + _msgItrf_dot_theta_03 <- (fromIntegral <$> getWord32le) + _msgItrf_dot_scale <- (fromIntegral <$> getWord16le) + pure MsgItrf {..} + + put MsgItrf {..} = do + putWord8 _msgItrf_ssr_iod + putWord8 _msgItrf_sn_counter_n + putByteString $ encodeUtf8 _msgItrf_sn + putWord8 _msgItrf_tn_counter_m + putByteString $ encodeUtf8 _msgItrf_tn + putWord8 _msgItrf_sin + putWord16le _msgItrf_utn + putWord16le _msgItrf_re_t0 + (putWord32le . fromIntegral) _msgItrf_delta_X0 + (putWord32le . fromIntegral) _msgItrf_delta_Y0 + (putWord32le . fromIntegral) _msgItrf_delta_Z0 + (putWord32le . fromIntegral) _msgItrf_theta_01 + (putWord32le . fromIntegral) _msgItrf_theta_02 + (putWord32le . fromIntegral) _msgItrf_theta_03 + (putWord32le . fromIntegral) _msgItrf_scale + (putWord32le . fromIntegral) _msgItrf_dot_delta_X0 + (putWord32le . fromIntegral) _msgItrf_dot_delta_Y0 + (putWord32le . fromIntegral) _msgItrf_dot_delta_Z0 + (putWord32le . fromIntegral) _msgItrf_dot_theta_01 + (putWord32le . fromIntegral) _msgItrf_dot_theta_02 + (putWord32le . fromIntegral) _msgItrf_dot_theta_03 + (putWord16le . fromIntegral) _msgItrf_dot_scale + +$(makeSBP 'msgItrf ''MsgItrf) +$(makeJSON "_msgItrf_" ''MsgItrf) +$(makeLenses ''MsgItrf) diff --git a/java/src/com/swiftnav/sbp/client/MessageTable.java b/java/src/com/swiftnav/sbp/client/MessageTable.java index c2f61d2544..398c4d3f39 100644 --- a/java/src/com/swiftnav/sbp/client/MessageTable.java +++ b/java/src/com/swiftnav/sbp/client/MessageTable.java @@ -79,6 +79,7 @@ import com.swiftnav.sbp.navigation.MsgGPSTime; import com.swiftnav.sbp.navigation.MsgGPSTimeDepA; import com.swiftnav.sbp.navigation.MsgGPSTimeGnss; +import com.swiftnav.sbp.navigation.MsgItrf; import com.swiftnav.sbp.navigation.MsgPosECEF; import com.swiftnav.sbp.navigation.MsgPosECEFCov; import com.swiftnav.sbp.navigation.MsgPosECEFCovGnss; @@ -420,6 +421,8 @@ static SBPMessage dispatch(SBPMessage msg) throws SBPBinaryException { return new MsgProtectionLevelDepA(msg); case MsgProtectionLevel.TYPE: return new MsgProtectionLevel(msg); + case MsgItrf.TYPE: + return new MsgItrf(msg); case MsgNdbEvent.TYPE: return new MsgNdbEvent(msg); case MsgObs.TYPE: diff --git a/java/src/com/swiftnav/sbp/navigation/MsgItrf.java b/java/src/com/swiftnav/sbp/navigation/MsgItrf.java new file mode 100644 index 0000000000..967751a54f --- /dev/null +++ b/java/src/com/swiftnav/sbp/navigation/MsgItrf.java @@ -0,0 +1,186 @@ +/* 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; + +public class MsgItrf extends SBPMessage { + public static final int TYPE = 0x0244; + + /** SSR IOD parameter. */ + public int ssr_iod; + + /** Source-Name Counter N. */ + public int sn_counter_n; + + /** Source-Name */ + public String sn; + + /** Target-Name Counter M. */ + public int tn_counter_m; + + /** Target-Name */ + public String tn; + + /** System Identification Number. */ + public int sin; + + /** Utilized Transformation Message. */ + public int utn; + + /** + * Reference Epoch t0 for transformation parameter set given as Modified Julian Day (MDJ) Number + * minus 44244 days. + */ + public int re_t0; + + /** Translation in X for Reference Epoch t0. */ + public int delta_X0; + + /** Translation in Y for Reference Epoch t0. */ + public int delta_Y0; + + /** Translation in Z for Reference Epoch t0. */ + public int delta_Z0; + + /** Rotation around the X-axis for Reference Epoch t0. */ + public int theta_01; + + /** Rotation around the Y-axis for Reference Epoch t0. */ + public int theta_02; + + /** Rotation around the Z-axis for Reference Epoch t0. */ + public int theta_03; + + /** Scale correction for Reference Epoch t0. */ + public int scale; + + /** Rate of change of translation in X. */ + public int dot_delta_X0; + + /** Rate of change of translation in Y. */ + public int dot_delta_Y0; + + /** Rate of change of translation in Z. */ + public int dot_delta_Z0; + + /** Rate of change of rotation around the X-axis. */ + public int dot_theta_01; + + /** Rate of change of rotation around the Y-axis. */ + public int dot_theta_02; + + /** Rate of change of rotation around the Z-axis. */ + public int dot_theta_03; + + /** Rate of change of scale correction. */ + public int dot_scale; + + public MsgItrf(int sender) { + super(sender, TYPE); + } + + public MsgItrf() { + super(TYPE); + } + + public MsgItrf(SBPMessage msg) throws SBPBinaryException { + super(msg); + assert msg.type == TYPE; + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + ssr_iod = parser.getU8(); + sn_counter_n = parser.getU8(); + sn = parser.getString(31); + tn_counter_m = parser.getU8(); + tn = parser.getString(31); + sin = parser.getU8(); + utn = parser.getU16(); + re_t0 = parser.getU16(); + delta_X0 = parser.getS32(); + delta_Y0 = parser.getS32(); + delta_Z0 = parser.getS32(); + theta_01 = parser.getS32(); + theta_02 = parser.getS32(); + theta_03 = parser.getS32(); + scale = parser.getS32(); + dot_delta_X0 = parser.getS32(); + dot_delta_Y0 = parser.getS32(); + dot_delta_Z0 = parser.getS32(); + dot_theta_01 = parser.getS32(); + dot_theta_02 = parser.getS32(); + dot_theta_03 = parser.getS32(); + dot_scale = parser.getS16(); + } + + @Override + protected void build(Builder builder) { + builder.putU8(ssr_iod); + builder.putU8(sn_counter_n); + builder.putString(sn, 31); + builder.putU8(tn_counter_m); + builder.putString(tn, 31); + builder.putU8(sin); + builder.putU16(utn); + builder.putU16(re_t0); + builder.putS32(delta_X0); + builder.putS32(delta_Y0); + builder.putS32(delta_Z0); + builder.putS32(theta_01); + builder.putS32(theta_02); + builder.putS32(theta_03); + builder.putS32(scale); + builder.putS32(dot_delta_X0); + builder.putS32(dot_delta_Y0); + builder.putS32(dot_delta_Z0); + builder.putS32(dot_theta_01); + builder.putS32(dot_theta_02); + builder.putS32(dot_theta_03); + builder.putS16(dot_scale); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("ssr_iod", ssr_iod); + obj.put("sn_counter_n", sn_counter_n); + obj.put("sn", sn); + obj.put("tn_counter_m", tn_counter_m); + obj.put("tn", tn); + obj.put("sin", sin); + obj.put("utn", utn); + obj.put("re_t0", re_t0); + obj.put("delta_X0", delta_X0); + obj.put("delta_Y0", delta_Y0); + obj.put("delta_Z0", delta_Z0); + obj.put("theta_01", theta_01); + obj.put("theta_02", theta_02); + obj.put("theta_03", theta_03); + obj.put("scale", scale); + obj.put("dot_delta_X0", dot_delta_X0); + obj.put("dot_delta_Y0", dot_delta_Y0); + obj.put("dot_delta_Z0", dot_delta_Z0); + obj.put("dot_theta_01", dot_theta_01); + obj.put("dot_theta_02", dot_theta_02); + obj.put("dot_theta_03", dot_theta_03); + obj.put("dot_scale", dot_scale); + return obj; + } +} diff --git a/java/test/auto_check_sbp_navigation_MsgItrfTest.java b/java/test/auto_check_sbp_navigation_MsgItrfTest.java new file mode 100644 index 0000000000..72810fc3b7 --- /dev/null +++ b/java/test/auto_check_sbp_navigation_MsgItrfTest.java @@ -0,0 +1,358 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.test; + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgItrf.yaml by +// generate.py. Do not modify by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.navigation.MsgItrf; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_navigation_MsgItrfTest { + + public static boolean debug = false; + private static final double DELTA = 1e-15; + + @Test + public void test1() throws Throwable { + if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgItrfTest.test1"); + byte[] payload = + new byte[] { + (byte) 1, + (byte) 2, + (byte) 102, + (byte) 111, + (byte) 111, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 3, + (byte) 98, + (byte) 97, + (byte) 114, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 4, + (byte) 5, + (byte) 0, + (byte) 6, + (byte) 0, + (byte) 7, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 8, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 9, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 10, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 11, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 12, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 13, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 14, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 15, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 16, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 17, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 18, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 19, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 20, + (byte) 0, + }; + SBPMessage sbp = new SBPMessage(0x0042, 0x0244, payload); + MsgItrf msg = new MsgItrf(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + value = msg.delta_X0; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.delta_X0 + "' != '" + 7 + "'", value.equals(BigInteger.valueOf(7L))); + } else { + value = value.longValue(); + expected = 7L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.delta_Y0; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.delta_Y0 + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + } else { + value = value.longValue(); + expected = 8L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.delta_Z0; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.delta_Z0 + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + } else { + value = value.longValue(); + expected = 9L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.dot_delta_X0; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.dot_delta_X0 + "' != '" + 14 + "'", + value.equals(BigInteger.valueOf(14L))); + } else { + value = value.longValue(); + expected = 14L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.dot_delta_Y0; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.dot_delta_Y0 + "' != '" + 15 + "'", + value.equals(BigInteger.valueOf(15L))); + } else { + value = value.longValue(); + expected = 15L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.dot_delta_Z0; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.dot_delta_Z0 + "' != '" + 16 + "'", + value.equals(BigInteger.valueOf(16L))); + } else { + value = value.longValue(); + expected = 16L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.dot_scale; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.dot_scale + "' != '" + 20 + "'", + value.equals(BigInteger.valueOf(20L))); + } else { + value = value.longValue(); + expected = 20L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.dot_theta_01; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.dot_theta_01 + "' != '" + 17 + "'", + value.equals(BigInteger.valueOf(17L))); + } else { + value = value.longValue(); + expected = 17L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.dot_theta_02; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.dot_theta_02 + "' != '" + 18 + "'", + value.equals(BigInteger.valueOf(18L))); + } else { + value = value.longValue(); + expected = 18L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.dot_theta_03; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.dot_theta_03 + "' != '" + 19 + "'", + value.equals(BigInteger.valueOf(19L))); + } else { + value = value.longValue(); + expected = 19L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.re_t0; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.re_t0 + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + } else { + value = value.longValue(); + expected = 6L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.scale; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.scale + "' != '" + 13 + "'", value.equals(BigInteger.valueOf(13L))); + } else { + value = value.longValue(); + expected = 13L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.sin; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.sin + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + } else { + value = value.longValue(); + expected = 4L; + org.junit.Assert.assertEquals(value, expected); + } + org.junit.Assert.assertEquals(msg.sn, "foo"); + value = msg.sn_counter_n; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.sn_counter_n + "' != '" + 2 + "'", + value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.ssr_iod; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.ssr_iod + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.theta_01; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.theta_01 + "' != '" + 10 + "'", + value.equals(BigInteger.valueOf(10L))); + } else { + value = value.longValue(); + expected = 10L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.theta_02; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.theta_02 + "' != '" + 11 + "'", + value.equals(BigInteger.valueOf(11L))); + } else { + value = value.longValue(); + expected = 11L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.theta_03; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.theta_03 + "' != '" + 12 + "'", + value.equals(BigInteger.valueOf(12L))); + } else { + value = value.longValue(); + expected = 12L; + org.junit.Assert.assertEquals(value, expected); + } + org.junit.Assert.assertEquals(msg.tn, "bar"); + value = msg.tn_counter_m; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.tn_counter_m + "' != '" + 3 + "'", + value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.utn; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.utn + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + } else { + value = value.longValue(); + expected = 5L; + org.junit.Assert.assertEquals(value, expected); + } + } +} diff --git a/javascript/sbp.bundle.js b/javascript/sbp.bundle.js index 6551517ae2..13278e5afa 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]),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}},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 $=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_A",this.fields=t||this.parser.parse(e.payload),this};($.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_DELAY_DEP_A",$.prototype.msg_type=146,$.prototype.constructor=$,$.prototype.parser=(new o).endianess("little").nest("t_op",{type:l.prototype.parser}).uint8("prn").uint8("valid").int16("tgd").int16("isc_l1ca").int16("isc_l2c"),$.prototype.fieldSpec=[],$.prototype.fieldSpec.push(["t_op",l.prototype.fieldSpec]),$.prototype.fieldSpec.push(["prn","writeUInt8",1]),$.prototype.fieldSpec.push(["valid","writeUInt8",1]),$.prototype.fieldSpec.push(["tgd","writeInt16LE",2]),$.prototype.fieldSpec.push(["isc_l1ca","writeInt16LE",2]),$.prototype.fieldSpec.push(["isc_l2c","writeInt16LE",2]);var Z=function(e,t){return r.call(this,e),this.messageType="MSG_GROUP_DELAY_DEP_B",this.fields=t||this.parser.parse(e.payload),this};(Z.prototype=Object.create(r.prototype)).messageType="MSG_GROUP_DELAY_DEP_B",Z.prototype.msg_type=147,Z.prototype.constructor=Z,Z.prototype.parser=(new o).endianess("little").nest("t_op",{type:c.prototype.parser}).nest("sid",{type:n.prototype.parser}).uint8("valid").int16("tgd").int16("isc_l1ca").int16("isc_l2c"),Z.prototype.fieldSpec=[],Z.prototype.fieldSpec.push(["t_op",c.prototype.fieldSpec]),Z.prototype.fieldSpec.push(["sid",n.prototype.fieldSpec]),Z.prototype.fieldSpec.push(["valid","writeUInt8",1]),Z.prototype.fieldSpec.push(["tgd","writeInt16LE",2]),Z.prototype.fieldSpec.push(["isc_l1ca","writeInt16LE",2]),Z.prototype.fieldSpec.push(["isc_l2c","writeInt16LE",2]);var ee=function(e,t){return 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:$,MsgGroupDelayDepA:$,147:Z,MsgGroupDelayDepB:Z,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_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 diff --git a/javascript/sbp/navigation.js b/javascript/sbp/navigation.js index 31df4792a9..1f4ece4414 100644 --- a/javascript/sbp/navigation.js +++ b/javascript/sbp/navigation.js @@ -2132,6 +2132,96 @@ 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_ITRF (0x0244). + * + + * Fields in the SBP payload (`sbp.payload`): + * @field ssr_iod number (unsigned 8-bit int, 1 byte) SSR IOD parameter. + * @field sn_counter_n number (unsigned 8-bit int, 1 byte) Source-Name Counter N. + * @field sn string Source-Name + * @field tn_counter_m number (unsigned 8-bit int, 1 byte) Target-Name Counter M. + * @field tn string Target-Name + * @field sin number (unsigned 8-bit int, 1 byte) System Identification Number. + * @field utn number (unsigned 16-bit int, 2 bytes) Utilized Transformation Message. + * @field re_t0 number (unsigned 16-bit int, 2 bytes) Reference Epoch t0 for transformation parameter set given as Modified Julian Day + * (MDJ) Number minus 44244 days. + * @field delta_X0 number (signed 32-bit int, 4 bytes) Translation in X for Reference Epoch t0. + * @field delta_Y0 number (signed 32-bit int, 4 bytes) Translation in Y for Reference Epoch t0. + * @field delta_Z0 number (signed 32-bit int, 4 bytes) Translation in Z for Reference Epoch t0. + * @field theta_01 number (signed 32-bit int, 4 bytes) Rotation around the X-axis for Reference Epoch t0. + * @field theta_02 number (signed 32-bit int, 4 bytes) Rotation around the Y-axis for Reference Epoch t0. + * @field theta_03 number (signed 32-bit int, 4 bytes) Rotation around the Z-axis for Reference Epoch t0. + * @field scale number (signed 32-bit int, 4 bytes) Scale correction for Reference Epoch t0. + * @field dot_delta_X0 number (signed 32-bit int, 4 bytes) Rate of change of translation in X. + * @field dot_delta_Y0 number (signed 32-bit int, 4 bytes) Rate of change of translation in Y. + * @field dot_delta_Z0 number (signed 32-bit int, 4 bytes) Rate of change of translation in Z. + * @field dot_theta_01 number (signed 32-bit int, 4 bytes) Rate of change of rotation around the X-axis. + * @field dot_theta_02 number (signed 32-bit int, 4 bytes) Rate of change of rotation around the Y-axis. + * @field dot_theta_03 number (signed 32-bit int, 4 bytes) Rate of change of rotation around the Z-axis. + * @field dot_scale number (signed 16-bit int, 2 bytes) Rate of change of scale correction. + * + * @param sbp An SBP object with a payload to be decoded. + */ +var MsgItrf = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_ITRF"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgItrf.prototype = Object.create(SBP.prototype); +MsgItrf.prototype.messageType = "MSG_ITRF"; +MsgItrf.prototype.msg_type = 0x0244; +MsgItrf.prototype.constructor = MsgItrf; +MsgItrf.prototype.parser = new Parser() + .endianess('little') + .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'); +MsgItrf.prototype.fieldSpec = []; +MsgItrf.prototype.fieldSpec.push(['ssr_iod', 'writeUInt8', 1]); +MsgItrf.prototype.fieldSpec.push(['sn_counter_n', 'writeUInt8', 1]); +MsgItrf.prototype.fieldSpec.push(['sn', 'string', 31]); +MsgItrf.prototype.fieldSpec.push(['tn_counter_m', 'writeUInt8', 1]); +MsgItrf.prototype.fieldSpec.push(['tn', 'string', 31]); +MsgItrf.prototype.fieldSpec.push(['sin', 'writeUInt8', 1]); +MsgItrf.prototype.fieldSpec.push(['utn', 'writeUInt16LE', 2]); +MsgItrf.prototype.fieldSpec.push(['re_t0', 'writeUInt16LE', 2]); +MsgItrf.prototype.fieldSpec.push(['delta_X0', 'writeInt32LE', 4]); +MsgItrf.prototype.fieldSpec.push(['delta_Y0', 'writeInt32LE', 4]); +MsgItrf.prototype.fieldSpec.push(['delta_Z0', 'writeInt32LE', 4]); +MsgItrf.prototype.fieldSpec.push(['theta_01', 'writeInt32LE', 4]); +MsgItrf.prototype.fieldSpec.push(['theta_02', 'writeInt32LE', 4]); +MsgItrf.prototype.fieldSpec.push(['theta_03', 'writeInt32LE', 4]); +MsgItrf.prototype.fieldSpec.push(['scale', 'writeInt32LE', 4]); +MsgItrf.prototype.fieldSpec.push(['dot_delta_X0', 'writeInt32LE', 4]); +MsgItrf.prototype.fieldSpec.push(['dot_delta_Y0', 'writeInt32LE', 4]); +MsgItrf.prototype.fieldSpec.push(['dot_delta_Z0', 'writeInt32LE', 4]); +MsgItrf.prototype.fieldSpec.push(['dot_theta_01', 'writeInt32LE', 4]); +MsgItrf.prototype.fieldSpec.push(['dot_theta_02', 'writeInt32LE', 4]); +MsgItrf.prototype.fieldSpec.push(['dot_theta_03', 'writeInt32LE', 4]); +MsgItrf.prototype.fieldSpec.push(['dot_scale', 'writeInt16LE', 2]); + module.exports = { 0x0102: MsgGpsTime, MsgGpsTime: MsgGpsTime, @@ -2210,4 +2300,6 @@ module.exports = { MsgProtectionLevelDepA: MsgProtectionLevelDepA, 0x0217: MsgProtectionLevel, MsgProtectionLevel: MsgProtectionLevel, + 0x0244: MsgItrf, + MsgItrf: MsgItrf, } \ No newline at end of file diff --git a/jsonschema/MsgItrf.json b/jsonschema/MsgItrf.json new file mode 100644 index 0000000000..58c7d85a9a --- /dev/null +++ b/jsonschema/MsgItrf.json @@ -0,0 +1,66 @@ +{ + "copyright": [ + "Copyright (C) 2019-2021 Swift Navigation Inc.", + "Contact: https://support.swiftnav.com", + "", + "This source is subject to the license found in the file 'LICENSE' which must", + "be be distributed together with this source. All other rights reserved.", + "", + "THIS CODE AND INFORMATION IS PROVIDED 'AS IS' WITHOUT WARRANTY OF ANY KIND,", + "EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED", + "WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE." + ], + "$schema": "http://json-schema.org/draft-06/schema#", + "$id": "#MsgItrf", + "title":"MsgItrf", + "description":"", + "type": "object", + "properties": { + "ssr_iod": {"type": "integer"}, + "sn_counter_n": {"type": "integer"}, + "sn": {"type": "string"}, + "tn_counter_m": {"type": "integer"}, + "tn": {"type": "string"}, + "sin": {"type": "integer"}, + "utn": {"type": "integer"}, + "re_t0": {"type": "integer"}, + "delta_X0": {"type": "integer"}, + "delta_Y0": {"type": "integer"}, + "delta_Z0": {"type": "integer"}, + "theta_01": {"type": "integer"}, + "theta_02": {"type": "integer"}, + "theta_03": {"type": "integer"}, + "scale": {"type": "integer"}, + "dot_delta_X0": {"type": "integer"}, + "dot_delta_Y0": {"type": "integer"}, + "dot_delta_Z0": {"type": "integer"}, + "dot_theta_01": {"type": "integer"}, + "dot_theta_02": {"type": "integer"}, + "dot_theta_03": {"type": "integer"}, + "dot_scale": {"type": "integer"} + }, + "required": [ + "ssr_iod", + "sn_counter_n", + "sn", + "tn_counter_m", + "tn", + "sin", + "utn", + "re_t0", + "delta_X0", + "delta_Y0", + "delta_Z0", + "theta_01", + "theta_02", + "theta_03", + "scale", + "dot_delta_X0", + "dot_delta_Y0", + "dot_delta_Z0", + "dot_theta_01", + "dot_theta_02", + "dot_theta_03", + "dot_scale" + ] +} \ No newline at end of file diff --git a/proto/navigation.proto b/proto/navigation.proto index b3acec3287..133b166f13 100644 --- a/proto/navigation.proto +++ b/proto/navigation.proto @@ -647,4 +647,33 @@ message MsgProtectionLevel { sint32 pitch = 19; sint32 heading = 20; uint32 flags = 21; +} + +/** Reference Frame Transformation Parameter + * +None + */ +message MsgItrf { + uint32 ssr_iod = 1; + uint32 sn_counter_n = 2; + string sn = 3; + uint32 tn_counter_m = 4; + string tn = 5; + uint32 sin = 6; + uint32 utn = 7; + uint32 re_t0 = 8; + sint32 delta_X0 = 9; + sint32 delta_Y0 = 10; + sint32 delta_Z0 = 11; + sint32 theta_01 = 12; + sint32 theta_02 = 13; + sint32 theta_03 = 14; + sint32 scale = 15; + sint32 dot_delta_X0 = 16; + sint32 dot_delta_Y0 = 17; + sint32 dot_delta_Z0 = 18; + sint32 dot_theta_01 = 19; + sint32 dot_theta_02 = 20; + sint32 dot_theta_03 = 21; + sint32 dot_scale = 22; } \ No newline at end of file diff --git a/python/sbp/navigation.py b/python/sbp/navigation.py index 49dad9d458..e6fb13349e 100755 --- a/python/sbp/navigation.py +++ b/python/sbp/navigation.py @@ -5105,6 +5105,200 @@ def to_json_dict(self): d.update(j) return d +SBP_MSG_ITRF = 0x0244 +class MsgItrf(SBP): + """SBP class for message MSG_ITRF (0x0244). + + You can have MSG_ITRF inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + ssr_iod : int + SSR IOD parameter. + sn_counter_n : int + Source-Name Counter N. + sn : string + Source-Name + tn_counter_m : int + Target-Name Counter M. + tn : string + Target-Name + sin : int + System Identification Number. + utn : int + Utilized Transformation Message. + re_t0 : int + Reference Epoch t0 for transformation parameter set given as Modified + Julian Day (MDJ) Number minus 44244 days. + delta_X0 : int + Translation in X for Reference Epoch t0. + delta_Y0 : int + Translation in Y for Reference Epoch t0. + delta_Z0 : int + Translation in Z for Reference Epoch t0. + theta_01 : int + Rotation around the X-axis for Reference Epoch t0. + theta_02 : int + Rotation around the Y-axis for Reference Epoch t0. + theta_03 : int + Rotation around the Z-axis for Reference Epoch t0. + scale : int + Scale correction for Reference Epoch t0. + dot_delta_X0 : int + Rate of change of translation in X. + dot_delta_Y0 : int + Rate of change of translation in Y. + dot_delta_Z0 : int + Rate of change of translation in Z. + dot_theta_01 : int + Rate of change of rotation around the X-axis. + dot_theta_02 : int + Rate of change of rotation around the Y-axis. + dot_theta_03 : int + Rate of change of rotation around the Z-axis. + dot_scale : int + Rate of change of scale correction. + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'ssr_iod' / construct.Int8ul, + 'sn_counter_n' / construct.Int8ul, + 'sn'/ construct.Bytes(31), + 'tn_counter_m' / construct.Int8ul, + 'tn'/ construct.Bytes(31), + 'sin' / construct.Int8ul, + 'utn' / construct.Int16ul, + 're_t0' / construct.Int16ul, + 'delta_X0' / construct.Int32sl, + 'delta_Y0' / construct.Int32sl, + 'delta_Z0' / construct.Int32sl, + 'theta_01' / construct.Int32sl, + 'theta_02' / construct.Int32sl, + 'theta_03' / construct.Int32sl, + 'scale' / construct.Int32sl, + 'dot_delta_X0' / construct.Int32sl, + 'dot_delta_Y0' / construct.Int32sl, + 'dot_delta_Z0' / construct.Int32sl, + 'dot_theta_01' / construct.Int32sl, + 'dot_theta_02' / construct.Int32sl, + 'dot_theta_03' / construct.Int32sl, + 'dot_scale' / construct.Int16sl,) + __slots__ = [ + 'ssr_iod', + 'sn_counter_n', + 'sn', + 'tn_counter_m', + 'tn', + 'sin', + 'utn', + 're_t0', + 'delta_X0', + 'delta_Y0', + 'delta_Z0', + 'theta_01', + 'theta_02', + 'theta_03', + 'scale', + 'dot_delta_X0', + 'dot_delta_Y0', + 'dot_delta_Z0', + 'dot_theta_01', + 'dot_theta_02', + 'dot_theta_03', + 'dot_scale', + ] + + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgItrf, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgItrf, self).__init__() + self.msg_type = SBP_MSG_ITRF + self.sender = kwargs.pop('sender', SENDER_ID) + self.ssr_iod = kwargs.pop('ssr_iod') + self.sn_counter_n = kwargs.pop('sn_counter_n') + self.sn = kwargs.pop('sn') + self.tn_counter_m = kwargs.pop('tn_counter_m') + self.tn = kwargs.pop('tn') + self.sin = kwargs.pop('sin') + self.utn = kwargs.pop('utn') + self.re_t0 = kwargs.pop('re_t0') + self.delta_X0 = kwargs.pop('delta_X0') + self.delta_Y0 = kwargs.pop('delta_Y0') + self.delta_Z0 = kwargs.pop('delta_Z0') + self.theta_01 = kwargs.pop('theta_01') + self.theta_02 = kwargs.pop('theta_02') + self.theta_03 = kwargs.pop('theta_03') + self.scale = kwargs.pop('scale') + self.dot_delta_X0 = kwargs.pop('dot_delta_X0') + self.dot_delta_Y0 = kwargs.pop('dot_delta_Y0') + self.dot_delta_Z0 = kwargs.pop('dot_delta_Z0') + self.dot_theta_01 = kwargs.pop('dot_theta_01') + self.dot_theta_02 = kwargs.pop('dot_theta_02') + self.dot_theta_03 = kwargs.pop('dot_theta_03') + self.dot_scale = kwargs.pop('dot_scale') + + def __repr__(self): + return fmt_repr(self) + + @staticmethod + def from_json(s): + """Given a JSON-encoded string s, build a message object. + + """ + d = json.loads(s) + return MsgItrf.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgItrf(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgItrf._parser.parse(d) + for n in self.__class__.__slots__: + setattr(self, n, getattr(p, n)) + + def to_binary(self): + """Produce a framed/packed SBP message. + + """ + c = containerize(exclude_fields(self)) + self.payload = MsgItrf._parser.build(c) + return self.pack() + + def into_buffer(self, buf, offset): + """Produce a framed/packed SBP message into the provided buffer and offset. + + """ + self.payload = containerize(exclude_fields(self)) + self.parser = MsgItrf._parser + self.stream_payload.reset(buf, offset) + return self.pack_into(buf, offset, self._build_payload) + + def to_json_dict(self): + self.to_binary() + d = super( MsgItrf, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + msg_classes = { 0x0102: MsgGPSTime, @@ -5145,4 +5339,5 @@ def to_json_dict(self): 0x0207: MsgBaselineHeadingDepA, 0x0216: MsgProtectionLevelDepA, 0x0217: MsgProtectionLevel, + 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 fc903931b5..6ccba39e37 100644 --- a/rust/sbp/src/messages/mod.rs +++ b/rust/sbp/src/messages/mod.rs @@ -99,6 +99,7 @@ use self::navigation::msg_dops_dep_a::MsgDopsDepA; use self::navigation::msg_gps_time::MsgGpsTime; use self::navigation::msg_gps_time_dep_a::MsgGpsTimeDepA; use self::navigation::msg_gps_time_gnss::MsgGpsTimeGnss; +use self::navigation::msg_itrf::MsgItrf; use self::navigation::msg_pos_ecef::MsgPosEcef; use self::navigation::msg_pos_ecef_cov::MsgPosEcefCov; use self::navigation::msg_pos_ecef_cov_gnss::MsgPosEcefCovGnss; @@ -649,6 +650,8 @@ pub enum Sbp { MsgPosEcefCovGnss(MsgPosEcefCovGnss), /// GNSS-only Velocity in ECEF MsgVelEcefCovGnss(MsgVelEcefCovGnss), + /// Reference Frame Transformation Parameter + MsgItrf(MsgItrf), /// Navigation DataBase Event MsgNdbEvent(MsgNdbEvent), /// Plaintext logging messages with levels @@ -1577,6 +1580,11 @@ impl Sbp { msg.set_sender_id(frame.sender_id); Ok(Sbp::MsgVelEcefCovGnss(msg)) } + MsgItrf::MESSAGE_TYPE => { + let mut msg = MsgItrf::parse(&mut frame.payload)?; + msg.set_sender_id(frame.sender_id); + Ok(Sbp::MsgItrf(msg)) + } MsgNdbEvent::MESSAGE_TYPE => { let mut msg = MsgNdbEvent::parse(&mut frame.payload)?; msg.set_sender_id(frame.sender_id); @@ -2058,6 +2066,7 @@ impl SbpMessage for Sbp { Sbp::MsgVelNedCovGnss(msg) => msg.message_name(), Sbp::MsgPosEcefCovGnss(msg) => msg.message_name(), Sbp::MsgVelEcefCovGnss(msg) => msg.message_name(), + Sbp::MsgItrf(msg) => msg.message_name(), Sbp::MsgNdbEvent(msg) => msg.message_name(), Sbp::MsgLog(msg) => msg.message_name(), Sbp::MsgFwd(msg) => msg.message_name(), @@ -2281,6 +2290,7 @@ impl SbpMessage for Sbp { Sbp::MsgVelNedCovGnss(msg) => msg.message_type(), Sbp::MsgPosEcefCovGnss(msg) => msg.message_type(), Sbp::MsgVelEcefCovGnss(msg) => msg.message_type(), + Sbp::MsgItrf(msg) => msg.message_type(), Sbp::MsgNdbEvent(msg) => msg.message_type(), Sbp::MsgLog(msg) => msg.message_type(), Sbp::MsgFwd(msg) => msg.message_type(), @@ -2504,6 +2514,7 @@ impl SbpMessage for Sbp { Sbp::MsgVelNedCovGnss(msg) => msg.sender_id(), Sbp::MsgPosEcefCovGnss(msg) => msg.sender_id(), Sbp::MsgVelEcefCovGnss(msg) => msg.sender_id(), + Sbp::MsgItrf(msg) => msg.sender_id(), Sbp::MsgNdbEvent(msg) => msg.sender_id(), Sbp::MsgLog(msg) => msg.sender_id(), Sbp::MsgFwd(msg) => msg.sender_id(), @@ -2727,6 +2738,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::MsgItrf(msg) => msg.set_sender_id(new_id), Sbp::MsgNdbEvent(msg) => msg.set_sender_id(new_id), Sbp::MsgLog(msg) => msg.set_sender_id(new_id), Sbp::MsgFwd(msg) => msg.set_sender_id(new_id), @@ -2950,6 +2962,7 @@ impl SbpMessage for Sbp { Sbp::MsgVelNedCovGnss(msg) => msg.encoded_len(), Sbp::MsgPosEcefCovGnss(msg) => msg.encoded_len(), Sbp::MsgVelEcefCovGnss(msg) => msg.encoded_len(), + Sbp::MsgItrf(msg) => msg.encoded_len(), Sbp::MsgNdbEvent(msg) => msg.encoded_len(), Sbp::MsgLog(msg) => msg.encoded_len(), Sbp::MsgFwd(msg) => msg.encoded_len(), @@ -3176,6 +3189,7 @@ impl SbpMessage for Sbp { Sbp::MsgVelNedCovGnss(msg) => msg.gps_time(), Sbp::MsgPosEcefCovGnss(msg) => msg.gps_time(), Sbp::MsgVelEcefCovGnss(msg) => msg.gps_time(), + Sbp::MsgItrf(msg) => msg.gps_time(), Sbp::MsgNdbEvent(msg) => msg.gps_time(), Sbp::MsgLog(msg) => msg.gps_time(), Sbp::MsgFwd(msg) => msg.gps_time(), @@ -3407,6 +3421,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::MsgItrf(msg) => WireFormat::write(msg, buf), Sbp::MsgNdbEvent(msg) => WireFormat::write(msg, buf), Sbp::MsgLog(msg) => WireFormat::write(msg, buf), Sbp::MsgFwd(msg) => WireFormat::write(msg, buf), @@ -3630,6 +3645,7 @@ impl WireFormat for Sbp { Sbp::MsgVelNedCovGnss(msg) => WireFormat::len(msg), Sbp::MsgPosEcefCovGnss(msg) => WireFormat::len(msg), Sbp::MsgVelEcefCovGnss(msg) => WireFormat::len(msg), + Sbp::MsgItrf(msg) => WireFormat::len(msg), Sbp::MsgNdbEvent(msg) => WireFormat::len(msg), Sbp::MsgLog(msg) => WireFormat::len(msg), Sbp::MsgFwd(msg) => WireFormat::len(msg), @@ -4622,6 +4638,12 @@ impl From for Sbp { } } +impl From for Sbp { + fn from(msg: MsgItrf) -> Self { + Sbp::MsgItrf(msg) + } +} + impl From for Sbp { fn from(msg: MsgNdbEvent) -> Self { Sbp::MsgNdbEvent(msg) diff --git a/rust/sbp/src/messages/navigation.rs b/rust/sbp/src/messages/navigation.rs index 222db5c4ca..626dcfa5e2 100644 --- a/rust/sbp/src/messages/navigation.rs +++ b/rust/sbp/src/messages/navigation.rs @@ -48,6 +48,7 @@ pub use msg_dops_dep_a::MsgDopsDepA; pub use msg_gps_time::MsgGpsTime; pub use msg_gps_time_dep_a::MsgGpsTimeDepA; pub use msg_gps_time_gnss::MsgGpsTimeGnss; +pub use msg_itrf::MsgItrf; pub use msg_pos_ecef::MsgPosEcef; pub use msg_pos_ecef_cov::MsgPosEcefCov; pub use msg_pos_ecef_cov_gnss::MsgPosEcefCovGnss; @@ -2137,6 +2138,221 @@ pub mod msg_gps_time_gnss { } } +pub mod msg_itrf { + #![allow(unused_imports)] + + use super::*; + use crate::messages::lib::*; + /// Reference Frame Transformation Parameter + #[cfg_attr(feature = "serde", derive(serde::Serialize))] + #[derive(Debug, Clone)] + pub struct MsgItrf { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing))] + pub sender_id: Option, + /// SSR IOD parameter. + #[cfg_attr(feature = "serde", serde(rename(serialize = "ssr_iod")))] + pub ssr_iod: u8, + /// Source-Name Counter N. + #[cfg_attr(feature = "serde", serde(rename(serialize = "sn_counter_n")))] + pub sn_counter_n: u8, + /// Source-Name + #[cfg_attr(feature = "serde", serde(rename(serialize = "sn")))] + pub sn: SbpString<[u8; 31], Unterminated>, + /// Target-Name Counter M. + #[cfg_attr(feature = "serde", serde(rename(serialize = "tn_counter_m")))] + pub tn_counter_m: u8, + /// Target-Name + #[cfg_attr(feature = "serde", serde(rename(serialize = "tn")))] + pub tn: SbpString<[u8; 31], Unterminated>, + /// System Identification Number. + #[cfg_attr(feature = "serde", serde(rename(serialize = "sin")))] + pub sin: u8, + /// Utilized Transformation Message. + #[cfg_attr(feature = "serde", serde(rename(serialize = "utn")))] + pub utn: u16, + /// Reference Epoch t0 for transformation parameter set given as Modified + /// Julian Day (MDJ) Number minus 44244 days. + #[cfg_attr(feature = "serde", serde(rename(serialize = "re_t0")))] + pub re_t0: u16, + /// Translation in X for Reference Epoch t0. + #[cfg_attr(feature = "serde", serde(rename(serialize = "delta_X0")))] + pub delta_x0: i32, + /// Translation in Y for Reference Epoch t0. + #[cfg_attr(feature = "serde", serde(rename(serialize = "delta_Y0")))] + pub delta_y0: i32, + /// Translation in Z for Reference Epoch t0. + #[cfg_attr(feature = "serde", serde(rename(serialize = "delta_Z0")))] + pub delta_z0: i32, + /// Rotation around the X-axis for Reference Epoch t0. + #[cfg_attr(feature = "serde", serde(rename(serialize = "theta_01")))] + pub theta_01: i32, + /// Rotation around the Y-axis for Reference Epoch t0. + #[cfg_attr(feature = "serde", serde(rename(serialize = "theta_02")))] + pub theta_02: i32, + /// Rotation around the Z-axis for Reference Epoch t0. + #[cfg_attr(feature = "serde", serde(rename(serialize = "theta_03")))] + pub theta_03: i32, + /// Scale correction for Reference Epoch t0. + #[cfg_attr(feature = "serde", serde(rename(serialize = "scale")))] + pub scale: i32, + /// Rate of change of translation in X. + #[cfg_attr(feature = "serde", serde(rename(serialize = "dot_delta_X0")))] + pub dot_delta_x0: i32, + /// Rate of change of translation in Y. + #[cfg_attr(feature = "serde", serde(rename(serialize = "dot_delta_Y0")))] + pub dot_delta_y0: i32, + /// Rate of change of translation in Z. + #[cfg_attr(feature = "serde", serde(rename(serialize = "dot_delta_Z0")))] + pub dot_delta_z0: i32, + /// Rate of change of rotation around the X-axis. + #[cfg_attr(feature = "serde", serde(rename(serialize = "dot_theta_01")))] + pub dot_theta_01: i32, + /// Rate of change of rotation around the Y-axis. + #[cfg_attr(feature = "serde", serde(rename(serialize = "dot_theta_02")))] + pub dot_theta_02: i32, + /// Rate of change of rotation around the Z-axis. + #[cfg_attr(feature = "serde", serde(rename(serialize = "dot_theta_03")))] + pub dot_theta_03: i32, + /// Rate of change of scale correction. + #[cfg_attr(feature = "serde", serde(rename(serialize = "dot_scale")))] + pub dot_scale: i16, + } + + impl ConcreteMessage for MsgItrf { + const MESSAGE_TYPE: u16 = 580; + const MESSAGE_NAME: &'static str = "MSG_ITRF"; + } + + impl SbpMessage for MsgItrf { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> u16 { + ::MESSAGE_TYPE + } + fn sender_id(&self) -> Option { + self.sender_id + } + fn set_sender_id(&mut self, new_id: u16) { + self.sender_id = Some(new_id); + } + fn encoded_len(&self) -> usize { + WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN + } + } + + impl TryFrom for MsgItrf { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgItrf(m) => Ok(m), + _ => Err(TryFromSbpError), + } + } + } + + impl WireFormat for MsgItrf { + const MIN_LEN: usize = ::MIN_LEN + + ::MIN_LEN + + as WireFormat>::MIN_LEN + + ::MIN_LEN + + as WireFormat>::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::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.ssr_iod) + + WireFormat::len(&self.sn_counter_n) + + WireFormat::len(&self.sn) + + WireFormat::len(&self.tn_counter_m) + + WireFormat::len(&self.tn) + + WireFormat::len(&self.sin) + + WireFormat::len(&self.utn) + + WireFormat::len(&self.re_t0) + + WireFormat::len(&self.delta_x0) + + WireFormat::len(&self.delta_y0) + + WireFormat::len(&self.delta_z0) + + WireFormat::len(&self.theta_01) + + WireFormat::len(&self.theta_02) + + WireFormat::len(&self.theta_03) + + WireFormat::len(&self.scale) + + WireFormat::len(&self.dot_delta_x0) + + WireFormat::len(&self.dot_delta_y0) + + WireFormat::len(&self.dot_delta_z0) + + WireFormat::len(&self.dot_theta_01) + + WireFormat::len(&self.dot_theta_02) + + WireFormat::len(&self.dot_theta_03) + + WireFormat::len(&self.dot_scale) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.ssr_iod, buf); + WireFormat::write(&self.sn_counter_n, buf); + WireFormat::write(&self.sn, buf); + WireFormat::write(&self.tn_counter_m, buf); + WireFormat::write(&self.tn, buf); + WireFormat::write(&self.sin, buf); + WireFormat::write(&self.utn, buf); + WireFormat::write(&self.re_t0, buf); + WireFormat::write(&self.delta_x0, buf); + WireFormat::write(&self.delta_y0, buf); + WireFormat::write(&self.delta_z0, buf); + WireFormat::write(&self.theta_01, buf); + WireFormat::write(&self.theta_02, buf); + WireFormat::write(&self.theta_03, buf); + WireFormat::write(&self.scale, buf); + WireFormat::write(&self.dot_delta_x0, buf); + WireFormat::write(&self.dot_delta_y0, buf); + WireFormat::write(&self.dot_delta_z0, buf); + WireFormat::write(&self.dot_theta_01, buf); + WireFormat::write(&self.dot_theta_02, buf); + WireFormat::write(&self.dot_theta_03, buf); + WireFormat::write(&self.dot_scale, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgItrf { + sender_id: None, + ssr_iod: WireFormat::parse_unchecked(buf), + sn_counter_n: WireFormat::parse_unchecked(buf), + sn: WireFormat::parse_unchecked(buf), + tn_counter_m: WireFormat::parse_unchecked(buf), + tn: WireFormat::parse_unchecked(buf), + sin: WireFormat::parse_unchecked(buf), + utn: WireFormat::parse_unchecked(buf), + re_t0: WireFormat::parse_unchecked(buf), + delta_x0: WireFormat::parse_unchecked(buf), + delta_y0: WireFormat::parse_unchecked(buf), + delta_z0: WireFormat::parse_unchecked(buf), + theta_01: WireFormat::parse_unchecked(buf), + theta_02: WireFormat::parse_unchecked(buf), + theta_03: WireFormat::parse_unchecked(buf), + scale: WireFormat::parse_unchecked(buf), + dot_delta_x0: WireFormat::parse_unchecked(buf), + dot_delta_y0: WireFormat::parse_unchecked(buf), + dot_delta_z0: WireFormat::parse_unchecked(buf), + dot_theta_01: WireFormat::parse_unchecked(buf), + dot_theta_02: WireFormat::parse_unchecked(buf), + dot_theta_03: WireFormat::parse_unchecked(buf), + dot_scale: WireFormat::parse_unchecked(buf), + } + } + } +} + pub mod msg_pos_ecef { #![allow(unused_imports)] diff --git a/rust/sbp/tests/integration/auto_check_sbp_navigation_msg_itrf.rs b/rust/sbp/tests/integration/auto_check_sbp_navigation_msg_itrf.rs new file mode 100644 index 0000000000000000000000000000000000000000..0a001b9642f550a4d0ebe3f91094ddf4e4baa84a GIT binary patch literal 6716 zcmcIpZExC05bkGw#e|a@bD{>5mnNKg5(VdCU4RJ4^{T3}9J7G$!1j69NobV+elvb2 z&|s%7ioo{nGxN;L&a5|$My1h!uH&vfYrYU5b!*USD(CN7&6Wb=dut|OVBA@ALs*Ut znr+GyMFLgs|9jXT+NRydL7P8Jpi?)aX`fUf-8f0!viI3N}b zmX^tE&S2*F_7p5TcsR3`3=Xfft~wa2hj72J%mu7`E=b-jqra)eg=gLRf=yA>oS`fa z?k%xE0f{~tI?E+E!B}7)2aj>)-LWZ|5wN?|#?T%1ROk$PpbajDqkdfhHRbv#Doa0FWa z`btxKb(G${y6I_yKj0(E7z`(HrS-K5&YBDXaq&zN6lu`ZG3n^5qwXat?0nR&G*pXR z8z}ign+#A5AZh5pb!Rlux;Iyy5nSJlu7_h)t^_8MLjsrH8ypN@IPd1nW}ZR5n|aO( zxXa9jU|jIV+E^_caTFW;)@@)kqwoh)^gf?!!kfu76K>ZK%aYx-3_S;IN5IONTC+8c zE)08mP^tJBVv{ts+rR!+sr>SVw0*72Fy45f6Di$XF!Ns>RqClqeZ}Xxh3cdlJXQcd z;Wu3^87lGxxW;xA8XmXoc`}`niBb>q4HGF%G7=Xj8jf)sv;_0?7318P zGcLW&q#){#)zdG{mu>bSq}s-F8k5-rE;=DqZ3iM*VGXRlFn4BPVWfJ8W_Y-wB47sc zlrmTu0;}fR*r-jD@M*gp+t6;0>9!v(Yzb-C;KT3FoIs=vj>S{x?7stP%ODy@q#Oy= z#oA?3Ee#Hh$Dfn4XBig{RI$N0o=5#5b_&UtF84KZKP$|gPziUeLixC_o8@x< zhAhqtb0<{79gAi@?%&Ge?g%}OC6?#oA_iAKA< zfemPC3AW(;mXw%J2_4D~?6_MlB5N`gXqP1$iA7yIza`~n7dMS1b_Co66f+~jCDEW= zL>?Og+?J|Wbb_FyVkq!+1j}lZwwi_N>IO71gZ4~$%!sxA1WRb=T&T*XmLN2>Bu}Z$ zK!1WIxPQf+=9b_Wmq+ASgr=6{DZHsAM_USCnOz>!1!i@T1s*{X>Nys604a-dv?`UO z0$zW}{rmW|i*h@QOq_wmZ(rrk zB1^M_<4cZ%Zx>3DH5Y>t_SnDnvJXLJ5szCKGB48nQ&`G9NAHheC9|hyS;X-Xjg3Z` z!}T$&WcJh`i)4O8W1~6dNc$L88v8so@Ye8ND1mQ&qy~!D*1#Xu9`Vv%bfkuan{T;Rt%4_f}=j%0pNkS6rTp} fI?&3T2nEo3d{!!3Ho`3%|79T6B7Z+so+|$XUgIpD literal 0 HcmV?d00001 diff --git a/rust/sbp/tests/integration/main.rs b/rust/sbp/tests/integration/main.rs index d714748939..5863442c03 100644 --- a/rust/sbp/tests/integration/main.rs +++ b/rust/sbp/tests/integration/main.rs @@ -37,6 +37,7 @@ mod auto_check_sbp_navigation_msg_dops_dep_a; mod auto_check_sbp_navigation_msg_gps_time; mod auto_check_sbp_navigation_msg_gps_time_dep_a; mod auto_check_sbp_navigation_msg_gps_time_gnss; +mod auto_check_sbp_navigation_msg_itrf; mod auto_check_sbp_navigation_msg_pos_ecef; mod auto_check_sbp_navigation_msg_pos_ecef_cov; mod auto_check_sbp_navigation_msg_pos_ecef_cov_gnss; diff --git a/sbpjson/elm/SbpJson.elm b/sbpjson/elm/SbpJson.elm index 504afade1e..487b7bf5cd 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, 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, 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 -- @@ -93,6 +93,7 @@ -- decodeString msgInsStatus myJsonString -- decodeString msgInsUpdates myJsonString -- decodeString msgIono myJsonString +-- decodeString msgItrf myJsonString -- decodeString msgLinuxCPUState myJsonString -- decodeString msgLinuxMemState myJsonString -- decodeString msgLinuxProcessFdCount myJsonString @@ -467,6 +468,9 @@ module SbpJson exposing , MsgIono , msgIonoToString , msgIono + , MsgItrf + , msgItrfToString + , msgItrf , MsgLinuxCPUState , msgLinuxCPUStateToString , msgLinuxCPUState @@ -1735,6 +1739,31 @@ type alias MsgIono = , tNmct : GpsTimeSEC } +type alias MsgItrf = + { deltaX0 : Int + , deltaY0 : Int + , deltaZ0 : Int + , dotDeltaX0 : Int + , dotDeltaY0 : Int + , dotDeltaZ0 : Int + , dotScale : Int + , dotTheta01 : Int + , dotTheta02 : Int + , dotTheta03 : Int + , reT0 : Int + , scale : Int + , sin : Int + , sn : String + , snCounterN : Int + , ssrIod : Int + , theta01 : Int + , theta02 : Int + , theta03 : Int + , tn : String + , tnCounterM : Int + , utn : Int + } + {-| This message indicates the process state of the top 10 heaviest consumers of CPU on the system, including a timestamp. -} @@ -3443,6 +3472,9 @@ msgInsUpdatesToString r = Jenc.encode 0 (encodeMsgInsUpdates r) msgIonoToString : MsgIono -> String msgIonoToString r = Jenc.encode 0 (encodeMsgIono r) +msgItrfToString : MsgItrf -> String +msgItrfToString r = Jenc.encode 0 (encodeMsgItrf r) + msgLinuxCPUStateToString : MsgLinuxCPUState -> String msgLinuxCPUStateToString r = Jenc.encode 0 (encodeMsgLinuxCPUState r) @@ -5213,6 +5245,59 @@ encodeMsgIono x = , ("t_nmct", encodeGpsTimeSEC x.tNmct) ] +msgItrf : Jdec.Decoder MsgItrf +msgItrf = + Jpipe.decode MsgItrf + |> Jpipe.required "delta_X0" Jdec.int + |> Jpipe.required "delta_Y0" Jdec.int + |> Jpipe.required "delta_Z0" Jdec.int + |> Jpipe.required "dot_delta_X0" Jdec.int + |> Jpipe.required "dot_delta_Y0" Jdec.int + |> Jpipe.required "dot_delta_Z0" Jdec.int + |> Jpipe.required "dot_scale" Jdec.int + |> Jpipe.required "dot_theta_01" Jdec.int + |> Jpipe.required "dot_theta_02" Jdec.int + |> Jpipe.required "dot_theta_03" Jdec.int + |> Jpipe.required "re_t0" Jdec.int + |> Jpipe.required "scale" Jdec.int + |> Jpipe.required "sin" Jdec.int + |> Jpipe.required "sn" Jdec.string + |> Jpipe.required "sn_counter_n" Jdec.int + |> Jpipe.required "ssr_iod" Jdec.int + |> Jpipe.required "theta_01" Jdec.int + |> Jpipe.required "theta_02" Jdec.int + |> Jpipe.required "theta_03" Jdec.int + |> Jpipe.required "tn" Jdec.string + |> Jpipe.required "tn_counter_m" Jdec.int + |> Jpipe.required "utn" Jdec.int + +encodeMsgItrf : MsgItrf -> Jenc.Value +encodeMsgItrf x = + Jenc.object + [ ("delta_X0", Jenc.int x.deltaX0) + , ("delta_Y0", Jenc.int x.deltaY0) + , ("delta_Z0", Jenc.int x.deltaZ0) + , ("dot_delta_X0", Jenc.int x.dotDeltaX0) + , ("dot_delta_Y0", Jenc.int x.dotDeltaY0) + , ("dot_delta_Z0", Jenc.int x.dotDeltaZ0) + , ("dot_scale", Jenc.int x.dotScale) + , ("dot_theta_01", Jenc.int x.dotTheta01) + , ("dot_theta_02", Jenc.int x.dotTheta02) + , ("dot_theta_03", Jenc.int x.dotTheta03) + , ("re_t0", Jenc.int x.reT0) + , ("scale", Jenc.int x.scale) + , ("sin", Jenc.int x.sin) + , ("sn", Jenc.string x.sn) + , ("sn_counter_n", Jenc.int x.snCounterN) + , ("ssr_iod", Jenc.int x.ssrIod) + , ("theta_01", Jenc.int x.theta01) + , ("theta_02", Jenc.int x.theta02) + , ("theta_03", Jenc.int x.theta03) + , ("tn", Jenc.string x.tn) + , ("tn_counter_m", Jenc.int x.tnCounterM) + , ("utn", Jenc.int x.utn) + ] + msgLinuxCPUState : Jdec.Decoder MsgLinuxCPUState msgLinuxCPUState = Jpipe.decode MsgLinuxCPUState diff --git a/sbpjson/javascript/SbpJson.js b/sbpjson/javascript/SbpJson.js index 146a268487..7c9ae014d3 100644 --- a/sbpjson/javascript/SbpJson.js +++ b/sbpjson/javascript/SbpJson.js @@ -86,6 +86,7 @@ // const msgInsStatus = Convert.toMsgInsStatus(json); // const msgInsUpdates = Convert.toMsgInsUpdates(json); // const msgIono = Convert.toMsgIono(json); +// const msgItrf = Convert.toMsgItrf(json); // const msgLinuxCPUState = Convert.toMsgLinuxCPUState(json); // const msgLinuxMemState = Convert.toMsgLinuxMemState(json); // const msgLinuxProcessFdCount = Convert.toMsgLinuxProcessFdCount(json); @@ -884,6 +885,14 @@ function msgIonoToJson(value) { return JSON.stringify(uncast(value, r("MsgIono")), null, 2); } +function toMsgItrf(json) { + return cast(JSON.parse(json), r("MsgItrf")); +} + +function msgItrfToJson(value) { + return JSON.stringify(uncast(value, r("MsgItrf")), null, 2); +} + function toMsgLinuxCPUState(json) { return cast(JSON.parse(json), r("MsgLinuxCPUState")); } @@ -2488,6 +2497,30 @@ const typeMap = { { json: "b3", js: "b3", typ: 3.14 }, { json: "t_nmct", js: "t_nmct", typ: r("GpsTimeSEC") }, ], "any"), + "MsgItrf": o([ + { json: "delta_X0", js: "delta_X0", typ: 0 }, + { json: "delta_Y0", js: "delta_Y0", typ: 0 }, + { json: "delta_Z0", js: "delta_Z0", typ: 0 }, + { json: "dot_delta_X0", js: "dot_delta_X0", typ: 0 }, + { json: "dot_delta_Y0", js: "dot_delta_Y0", typ: 0 }, + { json: "dot_delta_Z0", js: "dot_delta_Z0", typ: 0 }, + { json: "dot_scale", js: "dot_scale", typ: 0 }, + { json: "dot_theta_01", js: "dot_theta_01", typ: 0 }, + { json: "dot_theta_02", js: "dot_theta_02", typ: 0 }, + { json: "dot_theta_03", js: "dot_theta_03", typ: 0 }, + { json: "re_t0", js: "re_t0", typ: 0 }, + { json: "scale", js: "scale", typ: 0 }, + { json: "sin", js: "sin", typ: 0 }, + { json: "sn", js: "sn", typ: "" }, + { json: "sn_counter_n", js: "sn_counter_n", typ: 0 }, + { json: "ssr_iod", js: "ssr_iod", typ: 0 }, + { json: "theta_01", js: "theta_01", typ: 0 }, + { json: "theta_02", js: "theta_02", typ: 0 }, + { json: "theta_03", js: "theta_03", typ: 0 }, + { json: "tn", js: "tn", typ: "" }, + { json: "tn_counter_m", js: "tn_counter_m", typ: 0 }, + { json: "utn", js: "utn", typ: 0 }, + ], "any"), "MsgLinuxCPUState": o([ { json: "cmdline", js: "cmdline", typ: "" }, { json: "flags", js: "flags", typ: 0 }, @@ -3544,6 +3577,8 @@ module.exports = { "toMsgInsUpdates": toMsgInsUpdates, "msgIonoToJson": msgIonoToJson, "toMsgIono": toMsgIono, + "msgItrfToJson": msgItrfToJson, + "toMsgItrf": toMsgItrf, "msgLinuxCPUStateToJson": msgLinuxCPUStateToJson, "toMsgLinuxCPUState": toMsgLinuxCPUState, "msgLinuxMemStateToJson": msgLinuxMemStateToJson, diff --git a/sbpjson/typescript/SbpJson.ts b/sbpjson/typescript/SbpJson.ts index 07635ae625..3e81dd0639 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, 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, 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); @@ -86,6 +86,7 @@ // const msgInsStatus = Convert.toMsgInsStatus(json); // const msgInsUpdates = Convert.toMsgInsUpdates(json); // const msgIono = Convert.toMsgIono(json); +// const msgItrf = Convert.toMsgItrf(json); // const msgLinuxCPUState = Convert.toMsgLinuxCPUState(json); // const msgLinuxMemState = Convert.toMsgLinuxMemState(json); // const msgLinuxProcessFdCount = Convert.toMsgLinuxProcessFdCount(json); @@ -1168,6 +1169,31 @@ export interface MsgIono { t_nmct: GpsTimeSEC; } +export interface MsgItrf { + delta_X0: number; + delta_Y0: number; + delta_Z0: number; + dot_delta_X0: number; + dot_delta_Y0: number; + dot_delta_Z0: number; + dot_scale: number; + dot_theta_01: number; + dot_theta_02: number; + dot_theta_03: number; + re_t0: number; + scale: number; + sin: number; + sn: string; + sn_counter_n: number; + ssr_iod: number; + theta_01: number; + theta_02: number; + theta_03: number; + tn: string; + tn_counter_m: number; + utn: number; +} + /** * This message indicates the process state of the top 10 heaviest consumers of CPU on the * system, including a timestamp. @@ -3411,6 +3437,14 @@ export class Convert { return JSON.stringify(uncast(value, r("MsgIono")), null, 2); } + public static toMsgItrf(json: string): MsgItrf { + return cast(JSON.parse(json), r("MsgItrf")); + } + + public static msgItrfToJson(value: MsgItrf): string { + return JSON.stringify(uncast(value, r("MsgItrf")), null, 2); + } + public static toMsgLinuxCPUState(json: string): MsgLinuxCPUState { return cast(JSON.parse(json), r("MsgLinuxCPUState")); } @@ -5016,6 +5050,30 @@ const typeMap: any = { { json: "b3", js: "b3", typ: 3.14 }, { json: "t_nmct", js: "t_nmct", typ: r("GpsTimeSEC") }, ], "any"), + "MsgItrf": o([ + { json: "delta_X0", js: "delta_X0", typ: 0 }, + { json: "delta_Y0", js: "delta_Y0", typ: 0 }, + { json: "delta_Z0", js: "delta_Z0", typ: 0 }, + { json: "dot_delta_X0", js: "dot_delta_X0", typ: 0 }, + { json: "dot_delta_Y0", js: "dot_delta_Y0", typ: 0 }, + { json: "dot_delta_Z0", js: "dot_delta_Z0", typ: 0 }, + { json: "dot_scale", js: "dot_scale", typ: 0 }, + { json: "dot_theta_01", js: "dot_theta_01", typ: 0 }, + { json: "dot_theta_02", js: "dot_theta_02", typ: 0 }, + { json: "dot_theta_03", js: "dot_theta_03", typ: 0 }, + { json: "re_t0", js: "re_t0", typ: 0 }, + { json: "scale", js: "scale", typ: 0 }, + { json: "sin", js: "sin", typ: 0 }, + { json: "sn", js: "sn", typ: "" }, + { json: "sn_counter_n", js: "sn_counter_n", typ: 0 }, + { json: "ssr_iod", js: "ssr_iod", typ: 0 }, + { json: "theta_01", js: "theta_01", typ: 0 }, + { json: "theta_02", js: "theta_02", typ: 0 }, + { json: "theta_03", js: "theta_03", typ: 0 }, + { json: "tn", js: "tn", typ: "" }, + { json: "tn_counter_m", js: "tn_counter_m", typ: 0 }, + { json: "utn", js: "utn", typ: 0 }, + ], "any"), "MsgLinuxCPUState": o([ { json: "cmdline", js: "cmdline", typ: "" }, { json: "flags", js: "flags", typ: 0 },