From 5a31370f25dbc05e42365ce79a758b341ab1d422 Mon Sep 17 00:00:00 2001 From: Jason Mobarak Date: Mon, 25 Feb 2019 16:12:48 -0800 Subject: [PATCH 01/30] Add benchmark for jit crc method --- python/bench/crc.py | 51 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100755 python/bench/crc.py diff --git a/python/bench/crc.py b/python/bench/crc.py new file mode 100755 index 0000000000..7ca6a9e007 --- /dev/null +++ b/python/bench/crc.py @@ -0,0 +1,51 @@ +#!/usr/bin/env python + +# Copyright (C) 2019 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +import random +import timeit + +from sbp.msg import crc16, crc16_nojit + +blob_count = 5000 +blob_size = 256 + +blobs = [] + +print("Start: building random data...") + +for _ in range(blob_count): + blob = bytes(b'').join( + (chr(int(0xFF * random.random()) & 0xFF)) for X in range(blob_size)) + blobs.append(blob) + +print("End: building random data.") + + +def run_crc(): + for blob in blobs: + crc16(blob) + + +def run_crc2(): + for blob in blobs: + crc16_nojit(blob) + + +def main(): + t = timeit.Timer('run_crc()', 'from __main__ import run_crc').timeit(100) + print(t) + t = timeit.Timer('run_crc2()', 'from __main__ import run_crc2').timeit(100) + print(t) + + +if __name__ == '__main__': + main() From 5f1dfb7ac0d0fb82e81211fe4d7e6f5f5954e503 Mon Sep 17 00:00:00 2001 From: Jason Mobarak Date: Mon, 25 Feb 2019 16:19:05 -0800 Subject: [PATCH 02/30] Change iterator behavior to support sbp2json Will need to revisit this in other usages, this is probably more correct behavior but we'll need to adjust users of this iterator to expect the new behavior. --- python/sbp/client/framer.py | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/python/sbp/client/framer.py b/python/sbp/client/framer.py index bfc52bdd18..6270a088bb 100644 --- a/python/sbp/client/framer.py +++ b/python/sbp/client/framer.py @@ -102,14 +102,8 @@ def _readall(self, size): data = b"" while len(data) < size: d = self._read(size - len(data)) - if self._broken: + if not d or self._broken: raise StopIteration - if not d: - # NOTE (Buro/jgross): Force a yield here to another thread. In - # case the stream fails midstream, the spinning here causes - # the UI thread to lock up without yielding. - time.sleep(0) - continue data += d return data @@ -121,7 +115,7 @@ def _receive(self): # empty input preamble = self._read(1) if not preamble: - return None + raise StopIteration elif ord(preamble) != SBP_PREAMBLE: if self._verbose: print("Host Side Unhandled byte: 0x%02x" % ord(preamble)) From ed5dc6337c627c8ebb1e05e4d3b06d87eba54b3e Mon Sep 17 00:00:00 2001 From: Jason Mobarak Date: Mon, 25 Feb 2019 16:21:32 -0800 Subject: [PATCH 03/30] Allow clients to wait on Handler thread exit --- python/sbp/client/handler.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/python/sbp/client/handler.py b/python/sbp/client/handler.py index 85103a27d6..021f09fdd0 100644 --- a/python/sbp/client/handler.py +++ b/python/sbp/client/handler.py @@ -12,6 +12,7 @@ SBP message handling. """ +import warnings import collections import threading import weakref @@ -209,9 +210,13 @@ def stop(self): try: self._source.breakiter() self._receive_thread.join(0.1) - except: + except Exception as exc: + warnings.warn("Handler stop error: %s" % (exc,)) pass + def join(self, timeout=None): + self._receive_thread.join(timeout) + def is_alive(self): """ Return whether the processes thread is alive. From f36fa44ea7c058e2a55fab24b61cc38db2873b80 Mon Sep 17 00:00:00 2001 From: Jason Mobarak Date: Tue, 26 Feb 2019 19:27:19 -0800 Subject: [PATCH 04/30] Add flake8 config --- .flake8 | 1 + 1 file changed, 1 insertion(+) create mode 100644 .flake8 diff --git a/.flake8 b/.flake8 new file mode 100644 index 0000000000..ae13da549f --- /dev/null +++ b/.flake8 @@ -0,0 +1 @@ +max-line-length = 120 From 17ecd6210ad39687a0535be21e8614df5ad4ec3e Mon Sep 17 00:00:00 2001 From: Jason Mobarak Date: Tue, 26 Feb 2019 19:49:48 -0800 Subject: [PATCH 05/30] Generator for numba based parsing --- Makefile | 10 ++ generator/sbpg/generator.py | 8 +- generator/sbpg/targets/pythonNG.py | 150 ++++++++++++++++++ .../sbpg/targets/resources/sbp_numba.py.j2 | 99 ++++++++++++ python/requirements.txt | 2 + python/tests/sbp/test_numba.py | 90 +++++++++++ 6 files changed, 358 insertions(+), 1 deletion(-) create mode 100755 generator/sbpg/targets/pythonNG.py create mode 100755 generator/sbpg/targets/resources/sbp_numba.py.j2 create mode 100644 python/tests/sbp/test_numba.py diff --git a/Makefile b/Makefile index 199af30fda..ee1e3b5d30 100644 --- a/Makefile +++ b/Makefile @@ -61,6 +61,7 @@ docs: verify-prereq-docs pdf html c: deps-c gen-c test-c python: deps-python gen-python test-python +pythonNG: deps-python gen-pythonNG javascript: deps-javascript gen-javascript test-javascript java: deps-java gen-java test-java haskell: deps-haskell gen-haskell test-haskell @@ -144,6 +145,15 @@ gen-python: --python $(call announce-end,"Finished generating Python bindings. Please check $(SWIFTNAV_ROOT)/python/sbp") +gen-pythonNG: + $(call announce-begin,"Generating Python bindings") + cd $(SWIFTNAV_ROOT)/generator; \ + $(SBP_GEN_BIN) -i $(SBP_SPEC_DIR) \ + -o $(SWIFTNAV_ROOT)/python/sbp/jit \ + -r $(SBP_MAJOR_VERSION).$(SBP_MINOR_VERSION).$(SBP_PATCH_VERSION) \ + --pythonNG + $(call announce-end,"Finished generating Python bindings. Please check $(SWIFTNAV_ROOT)/python/sbp") + gen-javascript: $(call announce-begin,"Generating JavaScript bindings") cd $(SWIFTNAV_ROOT)/generator; \ diff --git a/generator/sbpg/generator.py b/generator/sbpg/generator.py index 8b6760382a..49cf7ac13b 100755 --- a/generator/sbpg/generator.py +++ b/generator/sbpg/generator.py @@ -25,6 +25,7 @@ import sbpg.targets.haskell as hs import sbpg.targets.protobuf as pb import sbpg.targets.python as py +import sbpg.targets.pythonNG as pyNG import sbpg.targets.javascript as js def get_args(): @@ -42,6 +43,9 @@ def get_args(): parser.add_argument('--python', action="store_true", help='Target language: Python.') + parser.add_argument('--pythonNG', + action="store_true", + help='Target language: Python.') parser.add_argument('--javascript', action="store_true", help='Target language: JavaScript.') @@ -80,7 +84,7 @@ def main(): # Parse and validate arguments. args = get_args().parse_args() verbose = args.verbose - assert args.python or args.javascript or args.c or args.test_c or args.haskell or args.latex or args.protobuf or args.java, \ + assert args.pythonNG or args.python or args.javascript or args.c or args.test_c or args.haskell or args.latex or args.protobuf or args.java, \ "Please specify a target language." input_file = os.path.abspath(args.input_file[0]) assert len(args.input_file) == 1 @@ -122,6 +126,8 @@ def main(): continue if args.python: py.render_source(output_dir, parsed) + if args.pythonNG: + pyNG.render_source(output_dir, parsed) elif args.javascript: js.render_source(output_dir, parsed) elif args.c: diff --git a/generator/sbpg/targets/pythonNG.py b/generator/sbpg/targets/pythonNG.py new file mode 100755 index 0000000000..36e21dac01 --- /dev/null +++ b/generator/sbpg/targets/pythonNG.py @@ -0,0 +1,150 @@ +#!/usr/bin/env python +# Copyright (C) 2015 Swift Navigation Inc. +# Contact: Bhaskar Mookerji +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +"""Generator for Python target. + +This module consumes the YAML spec and generates some message class +files. + +""" + +from sbpg.targets.templating import JENV, ACRONYMS +from sbpg.utils import comment_links +import copy + +TEMPLATE_NAME = "sbp_numba.py.j2" + +NUMBA_TYPE = { + 'u8': 'u1', + 'u16': 'u2', + 'u32': 'u4', + 'u64': 'u8', + 's8': 'i1', + 's16': 'i2', + 's32': 'i4', + 's64': 'i8', + 'float': 'f4', + 'double': 'f8', +} + +NUMBA_GET_FN = { + 'u8': 'get_u8', + 'u16': 'get_u16', + 'u32': 'get_u32', + 'u64': 'get_u64', + 's8': 'get_s8', + 's16': 'get_s16', + 's32': 'get_s32', + 's64': 'get_s64', + 'float': 'get_f32', + 'double': 'get_f64', +} + +NUMBA_TY_BYTES = { + 'u8': 1, + 'u16': 2, + 'u32': 4, + 'u64': 8, + 's8': 1, + 's16': 2, + 's32': 4, + 's64': 8, + 'float': 4, + 'double': 8, +} + +PYDOC_CODE = { + 'u8': 'int', + 'u16': 'int', + 'u32': 'int', + 'u64': 'int', + 's8': 'int', + 's16': 'int', + 's32': 'int', + 's64': 'int', + 'float': 'float', + 'double': 'double', +} + + +def is_array(): + return False + + +def numba_type(f): + return NUMBA_TYPE[f] + + +def numba_format(f): + if NUMBA_GET_FN.get(f.type_id, None): + return NUMBA_GET_FN.get(f.type_id) + elif f.type_id == 'string' and f.options.get('size', None): + s = f.options.get('size', None).value + return 'get_fixed_string(%d)' % (s,) + elif f.type_id == 'string' and not f.options.get('size', None): + return 'get_string' + elif f.type_id == 'array' and f.options.get('size', None): + count = f.options.get('size', None).value + t = NUMBA_GET_FN.get(f.type_id, 'u8') + if t not in NUMBA_GET_FN: + raise NotImplementedError() + fill_func = NUMBA_GET_FN[t] + el_size = NUMBA_TY_BYTES[t] + return "get_fixed_array(%s, %d, %d)" % (fill_func, count, el_size) + elif f.type_id == 'array': + fill = f.options['fill'].value + f_ = copy.copy(f) + f_.type_id = fill + return "get_array(%s)" % (numba_format(f_),) + else: + return '%s.parse_members' % (f.type_id) + raise NotImplementedError() + + +def pydoc_format(type_id, pydoc=PYDOC_CODE): + """ + Formats type for pydoc. + """ + return pydoc.get(type_id, type_id) + + +def classnameify(s): + """ + Makes a classname. + """ + return ''.join(w if w in ACRONYMS else w.title() for w in s.split('_')) + + +JENV.filters['numba_py'] = numba_format +JENV.filters['classnameify'] = classnameify +JENV.filters['pydoc'] = pydoc_format +JENV.filters['comment_links'] = comment_links + + +def render_source(output_dir, package_spec, jenv=JENV): + """ + Render and output + """ + path, name = package_spec.filepath + directory = output_dir + destination_filename = "%s/%s.py" % (directory, name) + py_template = jenv.get_template(TEMPLATE_NAME) + module_path = ".".join(package_spec.identifier.split(".")[1:-1]) + includes = [".".join(i.split(".")[:-1]) for i in package_spec.includes] + includes = [i for i in includes if i != "types"] + print(destination_filename, includes) + with open(destination_filename, 'w') as f: + f.write(py_template.render(msgs=package_spec.definitions, + filepath="/".join(package_spec.filepath) + ".yaml", + module_path=module_path, + include=includes, + timestamp=package_spec.creation_timestamp, + description=package_spec.description)) diff --git a/generator/sbpg/targets/resources/sbp_numba.py.j2 b/generator/sbpg/targets/resources/sbp_numba.py.j2 new file mode 100755 index 0000000000..c186945e48 --- /dev/null +++ b/generator/sbpg/targets/resources/sbp_numba.py.j2 @@ -0,0 +1,99 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +(((description|comment_links))) +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array + +((*- for i in include *)) +from (((module_path))).jit.(((i))) import * +((*- endfor *)) + +# Automatically generated from piksi/yaml/(((filepath))) with generate.py. +# Please do not hand edit! + +((*- for m in msgs *)) +((*- if m.static *)) + +((*- if m.sbp_id *)) +SBP_(((m.identifier))) = ((('0x%04X'|format(m.sbp_id)))) +((*- endif *)) + +((*- if m.sbp_id *)) +class ((( m.identifier | classnameify )))(SBP): + """SBP class for message (((m.identifier))) ((('(0x%04X)'|format(m.sbp_id)))). +((*- else *)) +class ((( m.identifier )))(object): + """SBP class for message (((m.identifier))) +((*- endif *)) + + You can have (((m.identifier))) inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + ((* if m.desc *)) + (((m.desc))) + ((*- endif *)) + + """ + ((*- if m.fields *)) + __slots__ = [((*- for f in m.fields *))'((( f.identifier )))', + ((* endfor *))] + ((*- else *)) + __slots__ = [] + ((*- endif *)) + + ((*- if m.fields *)) + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + ((*- for f in m.fields *)) + o_1, (__(((f.identifier))), offset, length) = offset, ((( f | numba_py )))(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + ((*- endfor *)) + return { + ((*- for f in m.fields *)) + '(((f.identifier)))' : __(((f.identifier))), + ((*- endfor *)) + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + ((*- for f in m.fields *)) + self.(((f.identifier))) = res['(((f.identifier)))'] + ((*- endfor *)) + return res, off, length + ((* else *)) + ((* endif *)) + +((*- endif *)) +((*- endfor *)) + +msg_classes = { +((*- for m in msgs *)) + ((*- if m.sbp_id *)) + ((('0x%04X'|format(m.sbp_id)))): ((( m.identifier | classnameify ))), + ((*- endif*)) +((*- endfor *)) +} diff --git a/python/requirements.txt b/python/requirements.txt index de9e140b13..befd25a028 100644 --- a/python/requirements.txt +++ b/python/requirements.txt @@ -6,3 +6,5 @@ requests>=2.8.1 llvmlite==0.26.0 numpy==1.16.2 numba==0.41.0 +pybase64 +cffi diff --git a/python/tests/sbp/test_numba.py b/python/tests/sbp/test_numba.py new file mode 100644 index 0000000000..fc5dbafb6f --- /dev/null +++ b/python/tests/sbp/test_numba.py @@ -0,0 +1,90 @@ +import numba as nb +import numpy as np + +from sbp.file_io import MsgFileioWriteReq +from sbp.jit.file_io import MsgFileioWriteReq as MsgFileioWriteReq_j + +from sbp.jit.msg import SBP + +from sbp.jit.msg import get_string +from sbp.jit.msg import get_fixed_string + +from sbp.jit.table import dispatch + + +def _mk_string(val, null='\x00'): + ba = bytearray(val + (null if null is not None else '')) + return np.array(ba, dtype=np.uint8) + + +def test_get_string(): + s = _mk_string('thisisastring') + out, offset, length = get_string(s, 0, len(s)) + assert len(out) == len('thisisastring') + assert out == 'thisisastring' + + +def test_get_string_no_null(): + s = _mk_string('thisisastring', null=None) + out, offset, length = get_string(s, 0, len(s)) + assert len(out) == len('thisisastring') + assert out == 'thisisastring' + + +def test_get_string_offset_no_null(): + s = _mk_string('________thisisastring', null=None) + out, offset, length = get_string(s, 8, len(s) - 8) + assert len(out) == len('thisisastring') + assert out == 'thisisastring' + + +def test_get_string_offset(): + s = _mk_string('________thisisastring') + out, offset, length = get_string(s, 8, len(s)) + assert len(out) == len('thisisastring') + assert out == 'thisisastring' + + +def test_get_fixed_string_offset(): + s = _mk_string('________thisisastring') + out, offset, length = get_fixed_string(6)(s, 8, len(s)) + assert len(out) == len('thisis') + assert out == 'thisis' + + +def test_parse(): + + header_len = 6 + data = b'floofydata' + + m = MsgFileioWriteReq( + sequence=123, + offset=42, + filename=b'floof.bin\0' + data, + data=b'') + + buf = m.to_binary() + b = buf.tobytes() + + assert b != b'' + + pkt_len, payload_len, msg_type, sender, crc, crc_fail = SBP.unpack_payload(buf, 0, len(buf)) + assert not crc_fail + + m = dispatch(msg_type)(msg_type) + res, offset, length = m.unpack(buf, header_len, payload_len) + + assert res is not None + + assert res['sequence'] == 123 + assert res['offset'] == 42 + assert res['filename'] == b'floof.bin' + + assert bytearray(res['data']) == bytearray(data) + + +def test_jit(): + @nb.jit('Tuple((Tuple((u2,u2)),u2))()', nopython=True, nogil=True) + def func(): + return ((123, 321), 42) + ((x, y), z) = func() From ca4f942b02043afacc5c928d354786bddcdfd686 Mon Sep 17 00:00:00 2001 From: Jason Mobarak Date: Tue, 26 Feb 2019 19:52:28 -0800 Subject: [PATCH 06/30] Add generated sbp classess --- python/sbp/jit/RELEASE-VERSION | 1 + python/sbp/jit/__init__.py | 0 python/sbp/jit/acquisition.py | 497 ++++ python/sbp/jit/bootload.py | 220 ++ python/sbp/jit/ext_events.py | 90 + python/sbp/jit/file_io.py | 458 ++++ python/sbp/jit/flash.py | 429 ++++ python/sbp/jit/gnss.py | 273 +++ python/sbp/jit/imu.py | 155 ++ python/sbp/jit/linux.py | 489 ++++ python/sbp/jit/logging.py | 155 ++ python/sbp/jit/mag.py | 87 + python/sbp/jit/msg.py | 293 +++ python/sbp/jit/navigation.py | 1930 +++++++++++++++ python/sbp/jit/ndb.py | 108 + python/sbp/jit/observation.py | 4042 ++++++++++++++++++++++++++++++++ python/sbp/jit/orientation.py | 319 +++ python/sbp/jit/piksi.py | 1252 ++++++++++ python/sbp/jit/sbas.py | 83 + python/sbp/jit/settings.py | 412 ++++ python/sbp/jit/ssr.py | 499 ++++ python/sbp/jit/system.py | 289 +++ python/sbp/jit/table.py | 88 + python/sbp/jit/tracking.py | 768 ++++++ python/sbp/jit/user.py | 65 + python/sbp/jit/vehicle.py | 79 + 26 files changed, 13081 insertions(+) create mode 100644 python/sbp/jit/RELEASE-VERSION create mode 100644 python/sbp/jit/__init__.py create mode 100644 python/sbp/jit/acquisition.py create mode 100644 python/sbp/jit/bootload.py create mode 100644 python/sbp/jit/ext_events.py create mode 100644 python/sbp/jit/file_io.py create mode 100644 python/sbp/jit/flash.py create mode 100644 python/sbp/jit/gnss.py create mode 100644 python/sbp/jit/imu.py create mode 100644 python/sbp/jit/linux.py create mode 100644 python/sbp/jit/logging.py create mode 100644 python/sbp/jit/mag.py create mode 100644 python/sbp/jit/msg.py create mode 100644 python/sbp/jit/navigation.py create mode 100644 python/sbp/jit/ndb.py create mode 100644 python/sbp/jit/observation.py create mode 100644 python/sbp/jit/orientation.py create mode 100644 python/sbp/jit/piksi.py create mode 100644 python/sbp/jit/sbas.py create mode 100644 python/sbp/jit/settings.py create mode 100644 python/sbp/jit/ssr.py create mode 100644 python/sbp/jit/system.py create mode 100755 python/sbp/jit/table.py create mode 100644 python/sbp/jit/tracking.py create mode 100644 python/sbp/jit/user.py create mode 100644 python/sbp/jit/vehicle.py diff --git a/python/sbp/jit/RELEASE-VERSION b/python/sbp/jit/RELEASE-VERSION new file mode 100644 index 0000000000..a6c4b4a24a --- /dev/null +++ b/python/sbp/jit/RELEASE-VERSION @@ -0,0 +1 @@ +2.4.10 \ No newline at end of file diff --git a/python/sbp/jit/__init__.py b/python/sbp/jit/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/python/sbp/jit/acquisition.py b/python/sbp/jit/acquisition.py new file mode 100644 index 0000000000..86f3849449 --- /dev/null +++ b/python/sbp/jit/acquisition.py @@ -0,0 +1,497 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Satellite acquisition messages from the device. +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array +from sbp.jit.gnss import * + +# Automatically generated from piksi/yaml/swiftnav/sbp/acquisition.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_ACQ_RESULT = 0x002F +class MsgAcqResult(SBP): + """SBP class for message MSG_ACQ_RESULT (0x002F). + + You can have MSG_ACQ_RESULT inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message describes the results from an attempted GPS signal +acquisition search for a satellite PRN over a code phase/carrier +frequency range. It contains the parameters of the point in the +acquisition search space with the best carrier-to-noise (CN/0) +ratio. + + + """ + __slots__ = ['cn0', + 'cp', + 'cf', + 'sid', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__cn0, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cp, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cf, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'cn0' : __cn0, + 'cp' : __cp, + 'cf' : __cf, + 'sid' : __sid, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.cn0 = res['cn0'] + self.cp = res['cp'] + self.cf = res['cf'] + self.sid = res['sid'] + return res, off, length + +SBP_MSG_ACQ_RESULT_DEP_C = 0x001F +class MsgAcqResultDepC(SBP): + """SBP class for message MSG_ACQ_RESULT_DEP_C (0x001F). + + You can have MSG_ACQ_RESULT_DEP_C inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['cn0', + 'cp', + 'cf', + 'sid', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__cn0, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cp, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cf, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'cn0' : __cn0, + 'cp' : __cp, + 'cf' : __cf, + 'sid' : __sid, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.cn0 = res['cn0'] + self.cp = res['cp'] + self.cf = res['cf'] + self.sid = res['sid'] + return res, off, length + +SBP_MSG_ACQ_RESULT_DEP_B = 0x0014 +class MsgAcqResultDepB(SBP): + """SBP class for message MSG_ACQ_RESULT_DEP_B (0x0014). + + You can have MSG_ACQ_RESULT_DEP_B inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['snr', + 'cp', + 'cf', + 'sid', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__snr, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cp, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cf, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'snr' : __snr, + 'cp' : __cp, + 'cf' : __cf, + 'sid' : __sid, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.snr = res['snr'] + self.cp = res['cp'] + self.cf = res['cf'] + self.sid = res['sid'] + return res, off, length + +SBP_MSG_ACQ_RESULT_DEP_A = 0x0015 +class MsgAcqResultDepA(SBP): + """SBP class for message MSG_ACQ_RESULT_DEP_A (0x0015). + + You can have MSG_ACQ_RESULT_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['snr', + 'cp', + 'cf', + 'prn', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__snr, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cp, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cf, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__prn, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'snr' : __snr, + 'cp' : __cp, + 'cf' : __cf, + 'prn' : __prn, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.snr = res['snr'] + self.cp = res['cp'] + self.cf = res['cf'] + self.prn = res['prn'] + return res, off, length + +class AcqSvProfile(object): + """SBP class for message AcqSvProfile + + You can have AcqSvProfile inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Profile for a specific SV for debugging purposes +The message describes SV profile during acquisition time. +The message is used to debug and measure the performance. + + + """ + __slots__ = ['job_type', + 'status', + 'cn0', + 'int_time', + 'sid', + 'bin_width', + 'timestamp', + 'time_spent', + 'cf_min', + 'cf_max', + 'cf', + 'cp', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__job_type, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__status, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cn0, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__int_time, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__bin_width, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__timestamp, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__time_spent, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cf_min, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cf_max, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cf, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cp, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'job_type' : __job_type, + 'status' : __status, + 'cn0' : __cn0, + 'int_time' : __int_time, + 'sid' : __sid, + 'bin_width' : __bin_width, + 'timestamp' : __timestamp, + 'time_spent' : __time_spent, + 'cf_min' : __cf_min, + 'cf_max' : __cf_max, + 'cf' : __cf, + 'cp' : __cp, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.job_type = res['job_type'] + self.status = res['status'] + self.cn0 = res['cn0'] + self.int_time = res['int_time'] + self.sid = res['sid'] + self.bin_width = res['bin_width'] + self.timestamp = res['timestamp'] + self.time_spent = res['time_spent'] + self.cf_min = res['cf_min'] + self.cf_max = res['cf_max'] + self.cf = res['cf'] + self.cp = res['cp'] + return res, off, length + +class AcqSvProfileDep(object): + """SBP class for message AcqSvProfileDep + + You can have AcqSvProfileDep inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['job_type', + 'status', + 'cn0', + 'int_time', + 'sid', + 'bin_width', + 'timestamp', + 'time_spent', + 'cf_min', + 'cf_max', + 'cf', + 'cp', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__job_type, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__status, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cn0, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__int_time, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__bin_width, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__timestamp, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__time_spent, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cf_min, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cf_max, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cf, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cp, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'job_type' : __job_type, + 'status' : __status, + 'cn0' : __cn0, + 'int_time' : __int_time, + 'sid' : __sid, + 'bin_width' : __bin_width, + 'timestamp' : __timestamp, + 'time_spent' : __time_spent, + 'cf_min' : __cf_min, + 'cf_max' : __cf_max, + 'cf' : __cf, + 'cp' : __cp, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.job_type = res['job_type'] + self.status = res['status'] + self.cn0 = res['cn0'] + self.int_time = res['int_time'] + self.sid = res['sid'] + self.bin_width = res['bin_width'] + self.timestamp = res['timestamp'] + self.time_spent = res['time_spent'] + self.cf_min = res['cf_min'] + self.cf_max = res['cf_max'] + self.cf = res['cf'] + self.cp = res['cp'] + return res, off, length + +SBP_MSG_ACQ_SV_PROFILE = 0x002E +class MsgAcqSvProfile(SBP): + """SBP class for message MSG_ACQ_SV_PROFILE (0x002E). + + You can have MSG_ACQ_SV_PROFILE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The message describes all SV profiles during acquisition time. +The message is used to debug and measure the performance. + + + """ + __slots__ = ['acq_sv_profile', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__acq_sv_profile, offset, length) = offset, get_array(AcqSvProfile.parse_members)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'acq_sv_profile' : __acq_sv_profile, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.acq_sv_profile = res['acq_sv_profile'] + return res, off, length + +SBP_MSG_ACQ_SV_PROFILE_DEP = 0x001E +class MsgAcqSvProfileDep(SBP): + """SBP class for message MSG_ACQ_SV_PROFILE_DEP (0x001E). + + You can have MSG_ACQ_SV_PROFILE_DEP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['acq_sv_profile', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__acq_sv_profile, offset, length) = offset, get_array(AcqSvProfileDep.parse_members)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'acq_sv_profile' : __acq_sv_profile, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.acq_sv_profile = res['acq_sv_profile'] + return res, off, length + + +msg_classes = { + 0x002F: MsgAcqResult, + 0x001F: MsgAcqResultDepC, + 0x0014: MsgAcqResultDepB, + 0x0015: MsgAcqResultDepA, + 0x002E: MsgAcqSvProfile, + 0x001E: MsgAcqSvProfileDep, +} \ No newline at end of file diff --git a/python/sbp/jit/bootload.py b/python/sbp/jit/bootload.py new file mode 100644 index 0000000000..31fb6ab6c2 --- /dev/null +++ b/python/sbp/jit/bootload.py @@ -0,0 +1,220 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Messages for the bootloading configuration of a Piksi 2.3.1. This message +group does not apply to Piksi Multi. + +Note that some of these messages share the same message type ID for both the +host request and the device response. + +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array + +# Automatically generated from piksi/yaml/swiftnav/sbp/bootload.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_BOOTLOADER_HANDSHAKE_REQ = 0x00B3 +class MsgBootloaderHandshakeReq(SBP): + """SBP class for message MSG_BOOTLOADER_HANDSHAKE_REQ (0x00B3). + + You can have MSG_BOOTLOADER_HANDSHAKE_REQ inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The handshake message request from the host establishes a +handshake between the device bootloader and the host. The +response from the device is MSG_BOOTLOADER_HANDSHAKE_RESP. + + + """ + __slots__ = [] + +SBP_MSG_BOOTLOADER_HANDSHAKE_RESP = 0x00B4 +class MsgBootloaderHandshakeResp(SBP): + """SBP class for message MSG_BOOTLOADER_HANDSHAKE_RESP (0x00B4). + + You can have MSG_BOOTLOADER_HANDSHAKE_RESP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The handshake message response from the device establishes a +handshake between the device bootloader and the host. The +request from the host is MSG_BOOTLOADER_HANDSHAKE_REQ. The +payload contains the bootloader version number and the SBP +protocol version number. + + + """ + __slots__ = ['flags', + 'version', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__flags, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__version, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'flags' : __flags, + 'version' : __version, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.flags = res['flags'] + self.version = res['version'] + return res, off, length + +SBP_MSG_BOOTLOADER_JUMP_TO_APP = 0x00B1 +class MsgBootloaderJumpToApp(SBP): + """SBP class for message MSG_BOOTLOADER_JUMP_TO_APP (0x00B1). + + You can have MSG_BOOTLOADER_JUMP_TO_APP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The host initiates the bootloader to jump to the application. + + + """ + __slots__ = ['jump', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__jump, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'jump' : __jump, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.jump = res['jump'] + return res, off, length + +SBP_MSG_NAP_DEVICE_DNA_REQ = 0x00DE +class MsgNapDeviceDnaReq(SBP): + """SBP class for message MSG_NAP_DEVICE_DNA_REQ (0x00DE). + + You can have MSG_NAP_DEVICE_DNA_REQ inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The device message from the host reads a unique device +identifier from the SwiftNAP, an FPGA. The host requests the ID +by sending a MSG_NAP_DEVICE_DNA_REQ message. The device +responds with a MSG_NAP_DEVICE_DNA_RESP message with the +device ID in the payload. Note that this ID is tied to the FPGA, +and not related to the Piksi's serial number. + + + """ + __slots__ = [] + +SBP_MSG_NAP_DEVICE_DNA_RESP = 0x00DD +class MsgNapDeviceDnaResp(SBP): + """SBP class for message MSG_NAP_DEVICE_DNA_RESP (0x00DD). + + You can have MSG_NAP_DEVICE_DNA_RESP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The device message from the host reads a unique device +identifier from the SwiftNAP, an FPGA. The host requests the ID +by sending a MSG_NAP_DEVICE_DNA_REQ message. The device +responds with a MSG_NAP_DEVICE_DNA_RESP messagage with the +device ID in the payload. Note that this ID is tied to the FPGA, +and not related to the Piksi's serial number. + + + """ + __slots__ = ['dna', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__dna, offset, length) = offset, get_fixed_array(get_u8, 8, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'dna' : __dna, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.dna = res['dna'] + return res, off, length + +SBP_MSG_BOOTLOADER_HANDSHAKE_DEP_A = 0x00B0 +class MsgBootloaderHandshakeDepA(SBP): + """SBP class for message MSG_BOOTLOADER_HANDSHAKE_DEP_A (0x00B0). + + You can have MSG_BOOTLOADER_HANDSHAKE_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['handshake', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__handshake, offset, length) = offset, get_array(get_u8)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'handshake' : __handshake, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.handshake = res['handshake'] + return res, off, length + + +msg_classes = { + 0x00B3: MsgBootloaderHandshakeReq, + 0x00B4: MsgBootloaderHandshakeResp, + 0x00B1: MsgBootloaderJumpToApp, + 0x00DE: MsgNapDeviceDnaReq, + 0x00DD: MsgNapDeviceDnaResp, + 0x00B0: MsgBootloaderHandshakeDepA, +} \ No newline at end of file diff --git a/python/sbp/jit/ext_events.py b/python/sbp/jit/ext_events.py new file mode 100644 index 0000000000..89af765a68 --- /dev/null +++ b/python/sbp/jit/ext_events.py @@ -0,0 +1,90 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Messages reporting accurately-timestamped external events, +e.g. camera shutter time. + +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array + +# Automatically generated from piksi/yaml/swiftnav/sbp/ext_events.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_EXT_EVENT = 0x0101 +class MsgExtEvent(SBP): + """SBP class for message MSG_EXT_EVENT (0x0101). + + You can have MSG_EXT_EVENT inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Reports detection of an external event, the GPS time it occurred, +which pin it was and whether it was rising or falling. + + + """ + __slots__ = ['wn', + 'tow', + 'ns_residual', + 'flags', + 'pin', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__wn, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ns_residual, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pin, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'wn' : __wn, + 'tow' : __tow, + 'ns_residual' : __ns_residual, + 'flags' : __flags, + 'pin' : __pin, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.wn = res['wn'] + self.tow = res['tow'] + self.ns_residual = res['ns_residual'] + self.flags = res['flags'] + self.pin = res['pin'] + return res, off, length + + +msg_classes = { + 0x0101: MsgExtEvent, +} \ No newline at end of file diff --git a/python/sbp/jit/file_io.py b/python/sbp/jit/file_io.py new file mode 100644 index 0000000000..e2e542574a --- /dev/null +++ b/python/sbp/jit/file_io.py @@ -0,0 +1,458 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Messages for using device's onboard flash filesystem +functionality. This allows data to be stored persistently in the +device's program flash with wear-levelling using a simple filesystem +interface. The file system interface (CFS) defines an abstract API +for reading directories and for reading and writing files. + +Note that some of these messages share the same message type ID for both the +host request and the device response. + +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array + +# Automatically generated from piksi/yaml/swiftnav/sbp/file_io.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_FILEIO_READ_REQ = 0x00A8 +class MsgFileioReadReq(SBP): + """SBP class for message MSG_FILEIO_READ_REQ (0x00A8). + + You can have MSG_FILEIO_READ_REQ inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The file read message reads a certain length (up to 255 bytes) +from a given offset into a file, and returns the data in a +MSG_FILEIO_READ_RESP message where the message length field +indicates how many bytes were succesfully read.The sequence +number in the request will be returned in the response. +If the message is invalid, a followup MSG_PRINT message will +print "Invalid fileio read message". A device will only respond +to this message when it is received from sender ID 0x42. + + + """ + __slots__ = ['sequence', + 'offset', + 'chunk_size', + 'filename', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__offset, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__chunk_size, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__filename, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sequence' : __sequence, + 'offset' : __offset, + 'chunk_size' : __chunk_size, + 'filename' : __filename, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sequence = res['sequence'] + self.offset = res['offset'] + self.chunk_size = res['chunk_size'] + self.filename = res['filename'] + return res, off, length + +SBP_MSG_FILEIO_READ_RESP = 0x00A3 +class MsgFileioReadResp(SBP): + """SBP class for message MSG_FILEIO_READ_RESP (0x00A3). + + You can have MSG_FILEIO_READ_RESP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The file read message reads a certain length (up to 255 bytes) +from a given offset into a file, and returns the data in a +message where the message length field indicates how many bytes +were succesfully read. The sequence number in the response is +preserved from the request. + + + """ + __slots__ = ['sequence', + 'contents', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__contents, offset, length) = offset, get_array(get_u8)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sequence' : __sequence, + 'contents' : __contents, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sequence = res['sequence'] + self.contents = res['contents'] + return res, off, length + +SBP_MSG_FILEIO_READ_DIR_REQ = 0x00A9 +class MsgFileioReadDirReq(SBP): + """SBP class for message MSG_FILEIO_READ_DIR_REQ (0x00A9). + + You can have MSG_FILEIO_READ_DIR_REQ inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The read directory message lists the files in a directory on the +device's onboard flash file system. The offset parameter can be +used to skip the first n elements of the file list. Returns a +MSG_FILEIO_READ_DIR_RESP message containing the directory +listings as a NULL delimited list. The listing is chunked over +multiple SBP packets. The sequence number in the request will be +returned in the response. If message is invalid, a followup +MSG_PRINT message will print "Invalid fileio read message". +A device will only respond to this message when it is received +from sender ID 0x42. + + + """ + __slots__ = ['sequence', + 'offset', + 'dirname', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__offset, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__dirname, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sequence' : __sequence, + 'offset' : __offset, + 'dirname' : __dirname, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sequence = res['sequence'] + self.offset = res['offset'] + self.dirname = res['dirname'] + return res, off, length + +SBP_MSG_FILEIO_READ_DIR_RESP = 0x00AA +class MsgFileioReadDirResp(SBP): + """SBP class for message MSG_FILEIO_READ_DIR_RESP (0x00AA). + + You can have MSG_FILEIO_READ_DIR_RESP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The read directory message lists the files in a directory on the +device's onboard flash file system. Message contains the directory +listings as a NULL delimited list. The listing is chunked over +multiple SBP packets and the end of the list is identified by an +entry containing just the character 0xFF. The sequence number in +the response is preserved from the request. + + + """ + __slots__ = ['sequence', + 'contents', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__contents, offset, length) = offset, get_array(get_u8)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sequence' : __sequence, + 'contents' : __contents, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sequence = res['sequence'] + self.contents = res['contents'] + return res, off, length + +SBP_MSG_FILEIO_REMOVE = 0x00AC +class MsgFileioRemove(SBP): + """SBP class for message MSG_FILEIO_REMOVE (0x00AC). + + You can have MSG_FILEIO_REMOVE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The file remove message deletes a file from the file system. +If the message is invalid, a followup MSG_PRINT message will +print "Invalid fileio remove message". A device will only +process this message when it is received from sender ID 0x42. + + + """ + __slots__ = ['filename', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__filename, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'filename' : __filename, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.filename = res['filename'] + return res, off, length + +SBP_MSG_FILEIO_WRITE_REQ = 0x00AD +class MsgFileioWriteReq(SBP): + """SBP class for message MSG_FILEIO_WRITE_REQ (0x00AD). + + You can have MSG_FILEIO_WRITE_REQ inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The file write message writes a certain length (up to 255 bytes) +of data to a file at a given offset. Returns a copy of the +original MSG_FILEIO_WRITE_RESP message to check integrity of +the write. The sequence number in the request will be returned +in the response. If message is invalid, a followup MSG_PRINT +message will print "Invalid fileio write message". A device will +only process this message when it is received from sender ID +0x42. + + + """ + __slots__ = ['sequence', + 'offset', + 'filename', + 'data', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__offset, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__filename, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__data, offset, length) = offset, get_array(get_u8)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sequence' : __sequence, + 'offset' : __offset, + 'filename' : __filename, + 'data' : __data, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sequence = res['sequence'] + self.offset = res['offset'] + self.filename = res['filename'] + self.data = res['data'] + return res, off, length + +SBP_MSG_FILEIO_WRITE_RESP = 0x00AB +class MsgFileioWriteResp(SBP): + """SBP class for message MSG_FILEIO_WRITE_RESP (0x00AB). + + You can have MSG_FILEIO_WRITE_RESP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The file write message writes a certain length (up to 255 bytes) +of data to a file at a given offset. The message is a copy of the +original MSG_FILEIO_WRITE_REQ message to check integrity of the +write. The sequence number in the response is preserved from the +request. + + + """ + __slots__ = ['sequence', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sequence' : __sequence, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sequence = res['sequence'] + return res, off, length + +SBP_MSG_FILEIO_CONFIG_REQ = 0x1001 +class MsgFileioConfigReq(SBP): + """SBP class for message MSG_FILEIO_CONFIG_REQ (0x1001). + + You can have MSG_FILEIO_CONFIG_REQ inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Requests advice on the optimal configuration for a FileIO +transfer. Newer version of FileIO can support greater +throughput by supporting a large window of FileIO data +that can be in-flight during read or write operations. + + + """ + __slots__ = ['sequence', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sequence' : __sequence, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sequence = res['sequence'] + return res, off, length + +SBP_MSG_FILEIO_CONFIG_RESP = 0x1002 +class MsgFileioConfigResp(SBP): + """SBP class for message MSG_FILEIO_CONFIG_RESP (0x1002). + + You can have MSG_FILEIO_CONFIG_RESP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The advice on the optimal configuration for a FileIO +transfer. Newer version of FileIO can support greater +throughput by supporting a large window of FileIO data +that can be in-flight during read or write operations. + + + """ + __slots__ = ['sequence', + 'window_size', + 'batch_size', + 'fileio_version', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__window_size, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__batch_size, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__fileio_version, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sequence' : __sequence, + 'window_size' : __window_size, + 'batch_size' : __batch_size, + 'fileio_version' : __fileio_version, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sequence = res['sequence'] + self.window_size = res['window_size'] + self.batch_size = res['batch_size'] + self.fileio_version = res['fileio_version'] + return res, off, length + + +msg_classes = { + 0x00A8: MsgFileioReadReq, + 0x00A3: MsgFileioReadResp, + 0x00A9: MsgFileioReadDirReq, + 0x00AA: MsgFileioReadDirResp, + 0x00AC: MsgFileioRemove, + 0x00AD: MsgFileioWriteReq, + 0x00AB: MsgFileioWriteResp, + 0x1001: MsgFileioConfigReq, + 0x1002: MsgFileioConfigResp, +} \ No newline at end of file diff --git a/python/sbp/jit/flash.py b/python/sbp/jit/flash.py new file mode 100644 index 0000000000..188e46c169 --- /dev/null +++ b/python/sbp/jit/flash.py @@ -0,0 +1,429 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Messages for reading/writing the device's onboard flash memory. Many +of these messages target specific flash memory peripherals used in +Swift Navigation devices: the STM32 flash and the M25Pxx FPGA +configuration flash from Piksi 2.3.1. This module does not apply +to Piksi Multi. + +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array + +# Automatically generated from piksi/yaml/swiftnav/sbp/flash.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_FLASH_PROGRAM = 0x00E6 +class MsgFlashProgram(SBP): + """SBP class for message MSG_FLASH_PROGRAM (0x00E6). + + You can have MSG_FLASH_PROGRAM inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The flash program message programs a set of addresses of either +the STM or M25 flash. The device replies with either a +MSG_FLASH_DONE message containing the return code FLASH_OK (0) +on success, or FLASH_INVALID_LEN (2) if the maximum write size +is exceeded. Note that the sector-containing addresses must be +erased before addresses can be programmed. + + + """ + __slots__ = ['target', + 'addr_start', + 'addr_len', + 'data', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__target, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__addr_start, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__addr_len, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__data, offset, length) = offset, get_array(get_u8)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'target' : __target, + 'addr_start' : __addr_start, + 'addr_len' : __addr_len, + 'data' : __data, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.target = res['target'] + self.addr_start = res['addr_start'] + self.addr_len = res['addr_len'] + self.data = res['data'] + return res, off, length + +SBP_MSG_FLASH_DONE = 0x00E0 +class MsgFlashDone(SBP): + """SBP class for message MSG_FLASH_DONE (0x00E0). + + You can have MSG_FLASH_DONE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message defines success or failure codes for a variety of +flash memory requests from the host to the device. Flash read +and write messages, such as MSG_FLASH_READ_REQ, or +MSG_FLASH_PROGRAM, may return this message on failure. + + + """ + __slots__ = ['response', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__response, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'response' : __response, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.response = res['response'] + return res, off, length + +SBP_MSG_FLASH_READ_REQ = 0x00E7 +class MsgFlashReadReq(SBP): + """SBP class for message MSG_FLASH_READ_REQ (0x00E7). + + You can have MSG_FLASH_READ_REQ inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The flash read message reads a set of addresses of either the +STM or M25 onboard flash. The device replies with a +MSG_FLASH_READ_RESP message containing either the read data on +success or a MSG_FLASH_DONE message containing the return code +FLASH_INVALID_LEN (2) if the maximum read size is exceeded or +FLASH_INVALID_ADDR (3) if the address is outside of the allowed +range. + + + """ + __slots__ = ['target', + 'addr_start', + 'addr_len', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__target, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__addr_start, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__addr_len, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'target' : __target, + 'addr_start' : __addr_start, + 'addr_len' : __addr_len, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.target = res['target'] + self.addr_start = res['addr_start'] + self.addr_len = res['addr_len'] + return res, off, length + +SBP_MSG_FLASH_READ_RESP = 0x00E1 +class MsgFlashReadResp(SBP): + """SBP class for message MSG_FLASH_READ_RESP (0x00E1). + + You can have MSG_FLASH_READ_RESP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The flash read message reads a set of addresses of either the +STM or M25 onboard flash. The device replies with a +MSG_FLASH_READ_RESP message containing either the read data on +success or a MSG_FLASH_DONE message containing the return code +FLASH_INVALID_LEN (2) if the maximum read size is exceeded or +FLASH_INVALID_ADDR (3) if the address is outside of the allowed +range. + + + """ + __slots__ = ['target', + 'addr_start', + 'addr_len', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__target, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__addr_start, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__addr_len, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'target' : __target, + 'addr_start' : __addr_start, + 'addr_len' : __addr_len, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.target = res['target'] + self.addr_start = res['addr_start'] + self.addr_len = res['addr_len'] + return res, off, length + +SBP_MSG_FLASH_ERASE = 0x00E2 +class MsgFlashErase(SBP): + """SBP class for message MSG_FLASH_ERASE (0x00E2). + + You can have MSG_FLASH_ERASE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The flash erase message from the host erases a sector of either +the STM or M25 onboard flash memory. The device will reply with a +MSG_FLASH_DONE message containing the return code - FLASH_OK (0) +on success or FLASH_INVALID_FLASH (1) if the flash specified is +invalid. + + + """ + __slots__ = ['target', + 'sector_num', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__target, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sector_num, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'target' : __target, + 'sector_num' : __sector_num, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.target = res['target'] + self.sector_num = res['sector_num'] + return res, off, length + +SBP_MSG_STM_FLASH_LOCK_SECTOR = 0x00E3 +class MsgStmFlashLockSector(SBP): + """SBP class for message MSG_STM_FLASH_LOCK_SECTOR (0x00E3). + + You can have MSG_STM_FLASH_LOCK_SECTOR inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The flash lock message locks a sector of the STM flash +memory. The device replies with a MSG_FLASH_DONE message. + + + """ + __slots__ = ['sector', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sector, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sector' : __sector, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sector = res['sector'] + return res, off, length + +SBP_MSG_STM_FLASH_UNLOCK_SECTOR = 0x00E4 +class MsgStmFlashUnlockSector(SBP): + """SBP class for message MSG_STM_FLASH_UNLOCK_SECTOR (0x00E4). + + You can have MSG_STM_FLASH_UNLOCK_SECTOR inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The flash unlock message unlocks a sector of the STM flash +memory. The device replies with a MSG_FLASH_DONE message. + + + """ + __slots__ = ['sector', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sector, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sector' : __sector, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sector = res['sector'] + return res, off, length + +SBP_MSG_STM_UNIQUE_ID_REQ = 0x00E8 +class MsgStmUniqueIdReq(SBP): + """SBP class for message MSG_STM_UNIQUE_ID_REQ (0x00E8). + + You can have MSG_STM_UNIQUE_ID_REQ inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reads the device's hardcoded unique ID. The host +requests the ID by sending a MSG_STM_UNIQUE_ID_REQ. The device +responds with a MSG_STM_UNIQUE_ID_RESP with the 12-byte unique +ID in the payload. + + + """ + __slots__ = [] + +SBP_MSG_STM_UNIQUE_ID_RESP = 0x00E5 +class MsgStmUniqueIdResp(SBP): + """SBP class for message MSG_STM_UNIQUE_ID_RESP (0x00E5). + + You can have MSG_STM_UNIQUE_ID_RESP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reads the device's hardcoded unique ID. The host +requests the ID by sending a MSG_STM_UNIQUE_ID_REQ. The device +responds with a MSG_STM_UNIQUE_ID_RESP with the 12-byte unique +ID in the payload.. + + + """ + __slots__ = ['stm_id', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__stm_id, offset, length) = offset, get_fixed_array(get_u8, 12, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'stm_id' : __stm_id, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.stm_id = res['stm_id'] + return res, off, length + +SBP_MSG_M25_FLASH_WRITE_STATUS = 0x00F3 +class MsgM25FlashWriteStatus(SBP): + """SBP class for message MSG_M25_FLASH_WRITE_STATUS (0x00F3). + + You can have MSG_M25_FLASH_WRITE_STATUS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The flash status message writes to the 8-bit M25 flash status +register. The device replies with a MSG_FLASH_DONE message. + + + """ + __slots__ = ['status', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__status, offset, length) = offset, get_fixed_array(get_u8, 1, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'status' : __status, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.status = res['status'] + return res, off, length + + +msg_classes = { + 0x00E6: MsgFlashProgram, + 0x00E0: MsgFlashDone, + 0x00E7: MsgFlashReadReq, + 0x00E1: MsgFlashReadResp, + 0x00E2: MsgFlashErase, + 0x00E3: MsgStmFlashLockSector, + 0x00E4: MsgStmFlashUnlockSector, + 0x00E8: MsgStmUniqueIdReq, + 0x00E5: MsgStmUniqueIdResp, + 0x00F3: MsgM25FlashWriteStatus, +} \ No newline at end of file diff --git a/python/sbp/jit/gnss.py b/python/sbp/jit/gnss.py new file mode 100644 index 0000000000..da81a3ca19 --- /dev/null +++ b/python/sbp/jit/gnss.py @@ -0,0 +1,273 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Various structs shared between modules +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array + +# Automatically generated from piksi/yaml/swiftnav/sbp/gnss.yaml with generate.py. +# Please do not hand edit! +class GnssSignal(object): + """SBP class for message GnssSignal + + You can have GnssSignal inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Signal identifier containing constellation, band, and satellite identifier + + + """ + __slots__ = ['sat', + 'code', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sat, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__code, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sat' : __sat, + 'code' : __code, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sat = res['sat'] + self.code = res['code'] + return res, off, length + +class GnssSignalDep(object): + """SBP class for message GnssSignalDep + + You can have GnssSignalDep inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['sat', + 'code', + 'reserved', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sat, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__code, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__reserved, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sat' : __sat, + 'code' : __code, + 'reserved' : __reserved, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sat = res['sat'] + self.code = res['code'] + self.reserved = res['reserved'] + return res, off, length + +class GPSTimeDep(object): + """SBP class for message GPSTimeDep + + You can have GPSTimeDep inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + A wire-appropriate GPS time, defined as the number of +milliseconds since beginning of the week on the Saturday/Sunday +transition. + + + """ + __slots__ = ['tow', + 'wn', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__wn, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'wn' : __wn, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.wn = res['wn'] + return res, off, length + +class GPSTimeSec(object): + """SBP class for message GPSTimeSec + + You can have GPSTimeSec inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + A GPS time, defined as the number of +seconds since beginning of the week on the Saturday/Sunday +transition. + + + """ + __slots__ = ['tow', + 'wn', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__wn, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'wn' : __wn, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.wn = res['wn'] + return res, off, length + +class GPSTime(object): + """SBP class for message GPSTime + + You can have GPSTime inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + A wire-appropriate receiver clock time, defined as the time +since the beginning of the week on the Saturday/Sunday +transition. In most cases, observations are epoch aligned +so ns field will be 0. + + + """ + __slots__ = ['tow', + 'ns_residual', + 'wn', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ns_residual, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__wn, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'ns_residual' : __ns_residual, + 'wn' : __wn, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.ns_residual = res['ns_residual'] + self.wn = res['wn'] + return res, off, length + +class CarrierPhase(object): + """SBP class for message CarrierPhase + + You can have CarrierPhase inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Carrier phase measurement in cycles represented as a 40-bit +fixed point number with Q32.8 layout, i.e. 32-bits of whole +cycles and 8-bits of fractional cycles. This phase has the +same sign as the pseudorange. + + + """ + __slots__ = ['i', + 'f', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__i, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__f, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'i' : __i, + 'f' : __f, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.i = res['i'] + self.f = res['f'] + return res, off, length + + +msg_classes = { +} \ No newline at end of file diff --git a/python/sbp/jit/imu.py b/python/sbp/jit/imu.py new file mode 100644 index 0000000000..6a4be740c6 --- /dev/null +++ b/python/sbp/jit/imu.py @@ -0,0 +1,155 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Inertial Measurement Unit (IMU) messages. +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array + +# Automatically generated from piksi/yaml/swiftnav/sbp/imu.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_IMU_RAW = 0x0900 +class MsgImuRaw(SBP): + """SBP class for message MSG_IMU_RAW (0x0900). + + You can have MSG_IMU_RAW inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Raw data from the Inertial Measurement Unit, containing accelerometer and +gyroscope readings. The sense of the measurements are to be aligned with +the indications on the device itself. Measurement units, which are specific to the +device hardware and settings, are communicated via the MSG_IMU_AUX message. + + + """ + __slots__ = ['tow', + 'tow_f', + 'acc_x', + 'acc_y', + 'acc_z', + 'gyr_x', + 'gyr_y', + 'gyr_z', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tow_f, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__acc_x, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__acc_y, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__acc_z, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__gyr_x, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__gyr_y, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__gyr_z, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'tow_f' : __tow_f, + 'acc_x' : __acc_x, + 'acc_y' : __acc_y, + 'acc_z' : __acc_z, + 'gyr_x' : __gyr_x, + 'gyr_y' : __gyr_y, + 'gyr_z' : __gyr_z, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.tow_f = res['tow_f'] + self.acc_x = res['acc_x'] + self.acc_y = res['acc_y'] + self.acc_z = res['acc_z'] + self.gyr_x = res['gyr_x'] + self.gyr_y = res['gyr_y'] + self.gyr_z = res['gyr_z'] + return res, off, length + +SBP_MSG_IMU_AUX = 0x0901 +class MsgImuAux(SBP): + """SBP class for message MSG_IMU_AUX (0x0901). + + You can have MSG_IMU_AUX inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Auxiliary data specific to a particular IMU. The `imu_type` field will +always be consistent but the rest of the payload is device specific and +depends on the value of `imu_type`. + + + """ + __slots__ = ['imu_type', + 'temp', + 'imu_conf', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__imu_type, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__temp, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__imu_conf, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'imu_type' : __imu_type, + 'temp' : __temp, + 'imu_conf' : __imu_conf, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.imu_type = res['imu_type'] + self.temp = res['temp'] + self.imu_conf = res['imu_conf'] + return res, off, length + + +msg_classes = { + 0x0900: MsgImuRaw, + 0x0901: MsgImuAux, +} \ No newline at end of file diff --git a/python/sbp/jit/linux.py b/python/sbp/jit/linux.py new file mode 100644 index 0000000000..277d07cdf8 --- /dev/null +++ b/python/sbp/jit/linux.py @@ -0,0 +1,489 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Linux state monitoring. + +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array + +# Automatically generated from piksi/yaml/swiftnav/sbp/linux.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_LINUX_CPU_STATE = 0x7F00 +class MsgLinuxCpuState(SBP): + """SBP class for message MSG_LINUX_CPU_STATE (0x7F00). + + You can have MSG_LINUX_CPU_STATE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message indicates the process state of the top 10 heaviest +consumers of CPU on the system. + + + """ + __slots__ = ['index', + 'pid', + 'pcpu', + 'tname', + 'cmdline', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__index, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pid, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pcpu, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tname, offset, length) = offset, get_fixed_string(15)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cmdline, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'index' : __index, + 'pid' : __pid, + 'pcpu' : __pcpu, + 'tname' : __tname, + 'cmdline' : __cmdline, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.index = res['index'] + self.pid = res['pid'] + self.pcpu = res['pcpu'] + self.tname = res['tname'] + self.cmdline = res['cmdline'] + return res, off, length + +SBP_MSG_LINUX_MEM_STATE = 0x7F01 +class MsgLinuxMemState(SBP): + """SBP class for message MSG_LINUX_MEM_STATE (0x7F01). + + You can have MSG_LINUX_MEM_STATE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message indicates the process state of the top 10 heaviest +consumers of memory on the system. + + + """ + __slots__ = ['index', + 'pid', + 'pmem', + 'tname', + 'cmdline', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__index, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pid, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pmem, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tname, offset, length) = offset, get_fixed_string(15)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cmdline, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'index' : __index, + 'pid' : __pid, + 'pmem' : __pmem, + 'tname' : __tname, + 'cmdline' : __cmdline, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.index = res['index'] + self.pid = res['pid'] + self.pmem = res['pmem'] + self.tname = res['tname'] + self.cmdline = res['cmdline'] + return res, off, length + +SBP_MSG_LINUX_SYS_STATE = 0x7F02 +class MsgLinuxSysState(SBP): + """SBP class for message MSG_LINUX_SYS_STATE (0x7F02). + + You can have MSG_LINUX_SYS_STATE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This presents a summary of CPU and memory utilization. + + + """ + __slots__ = ['mem_total', + 'pcpu', + 'pmem', + 'procs_starting', + 'procs_stopping', + 'pid_count', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__mem_total, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pcpu, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pmem, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__procs_starting, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__procs_stopping, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pid_count, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'mem_total' : __mem_total, + 'pcpu' : __pcpu, + 'pmem' : __pmem, + 'procs_starting' : __procs_starting, + 'procs_stopping' : __procs_stopping, + 'pid_count' : __pid_count, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.mem_total = res['mem_total'] + self.pcpu = res['pcpu'] + self.pmem = res['pmem'] + self.procs_starting = res['procs_starting'] + self.procs_stopping = res['procs_stopping'] + self.pid_count = res['pid_count'] + return res, off, length + +SBP_MSG_LINUX_PROCESS_SOCKET_COUNTS = 0x7F03 +class MsgLinuxProcessSocketCounts(SBP): + """SBP class for message MSG_LINUX_PROCESS_SOCKET_COUNTS (0x7F03). + + You can have MSG_LINUX_PROCESS_SOCKET_COUNTS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Top 10 list of processes with high socket counts. + + + """ + __slots__ = ['index', + 'pid', + 'socket_count', + 'socket_types', + 'socket_states', + 'cmdline', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__index, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pid, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__socket_count, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__socket_types, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__socket_states, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cmdline, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'index' : __index, + 'pid' : __pid, + 'socket_count' : __socket_count, + 'socket_types' : __socket_types, + 'socket_states' : __socket_states, + 'cmdline' : __cmdline, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.index = res['index'] + self.pid = res['pid'] + self.socket_count = res['socket_count'] + self.socket_types = res['socket_types'] + self.socket_states = res['socket_states'] + self.cmdline = res['cmdline'] + return res, off, length + +SBP_MSG_LINUX_PROCESS_SOCKET_QUEUES = 0x7F04 +class MsgLinuxProcessSocketQueues(SBP): + """SBP class for message MSG_LINUX_PROCESS_SOCKET_QUEUES (0x7F04). + + You can have MSG_LINUX_PROCESS_SOCKET_QUEUES inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Top 10 list of sockets with deep queues. + + + """ + __slots__ = ['index', + 'pid', + 'recv_queued', + 'send_queued', + 'socket_types', + 'socket_states', + 'address_of_largest', + 'cmdline', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__index, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pid, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__recv_queued, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__send_queued, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__socket_types, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__socket_states, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__address_of_largest, offset, length) = offset, get_fixed_string(64)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cmdline, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'index' : __index, + 'pid' : __pid, + 'recv_queued' : __recv_queued, + 'send_queued' : __send_queued, + 'socket_types' : __socket_types, + 'socket_states' : __socket_states, + 'address_of_largest' : __address_of_largest, + 'cmdline' : __cmdline, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.index = res['index'] + self.pid = res['pid'] + self.recv_queued = res['recv_queued'] + self.send_queued = res['send_queued'] + self.socket_types = res['socket_types'] + self.socket_states = res['socket_states'] + self.address_of_largest = res['address_of_largest'] + self.cmdline = res['cmdline'] + return res, off, length + +SBP_MSG_LINUX_SOCKET_USAGE = 0x7F05 +class MsgLinuxSocketUsage(SBP): + """SBP class for message MSG_LINUX_SOCKET_USAGE (0x7F05). + + You can have MSG_LINUX_SOCKET_USAGE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Summaries the socket usage across the system. + + + """ + __slots__ = ['avg_queue_depth', + 'max_queue_depth', + 'socket_state_counts', + 'socket_type_counts', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__avg_queue_depth, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__max_queue_depth, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__socket_state_counts, offset, length) = offset, get_fixed_array(get_u8, 16, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__socket_type_counts, offset, length) = offset, get_fixed_array(get_u8, 16, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'avg_queue_depth' : __avg_queue_depth, + 'max_queue_depth' : __max_queue_depth, + 'socket_state_counts' : __socket_state_counts, + 'socket_type_counts' : __socket_type_counts, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.avg_queue_depth = res['avg_queue_depth'] + self.max_queue_depth = res['max_queue_depth'] + self.socket_state_counts = res['socket_state_counts'] + self.socket_type_counts = res['socket_type_counts'] + return res, off, length + +SBP_MSG_LINUX_PROCESS_FD_COUNT = 0x7F06 +class MsgLinuxProcessFdCount(SBP): + """SBP class for message MSG_LINUX_PROCESS_FD_COUNT (0x7F06). + + You can have MSG_LINUX_PROCESS_FD_COUNT inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Top 10 list of processes with a large number of open file descriptors. + + + """ + __slots__ = ['index', + 'pid', + 'fd_count', + 'cmdline', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__index, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pid, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__fd_count, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cmdline, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'index' : __index, + 'pid' : __pid, + 'fd_count' : __fd_count, + 'cmdline' : __cmdline, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.index = res['index'] + self.pid = res['pid'] + self.fd_count = res['fd_count'] + self.cmdline = res['cmdline'] + return res, off, length + +SBP_MSG_LINUX_PROCESS_FD_SUMMARY = 0x7F07 +class MsgLinuxProcessFdSummary(SBP): + """SBP class for message MSG_LINUX_PROCESS_FD_SUMMARY (0x7F07). + + You can have MSG_LINUX_PROCESS_FD_SUMMARY inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Summary of open file descriptors on the system. + + + """ + __slots__ = ['sys_fd_count', + 'most_opened', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sys_fd_count, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__most_opened, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sys_fd_count' : __sys_fd_count, + 'most_opened' : __most_opened, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sys_fd_count = res['sys_fd_count'] + self.most_opened = res['most_opened'] + return res, off, length + + +msg_classes = { + 0x7F00: MsgLinuxCpuState, + 0x7F01: MsgLinuxMemState, + 0x7F02: MsgLinuxSysState, + 0x7F03: MsgLinuxProcessSocketCounts, + 0x7F04: MsgLinuxProcessSocketQueues, + 0x7F05: MsgLinuxSocketUsage, + 0x7F06: MsgLinuxProcessFdCount, + 0x7F07: MsgLinuxProcessFdSummary, +} \ No newline at end of file diff --git a/python/sbp/jit/logging.py b/python/sbp/jit/logging.py new file mode 100644 index 0000000000..dd244bf70d --- /dev/null +++ b/python/sbp/jit/logging.py @@ -0,0 +1,155 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Logging and debugging messages from the device. + +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array + +# Automatically generated from piksi/yaml/swiftnav/sbp/logging.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_LOG = 0x0401 +class MsgLog(SBP): + """SBP class for message MSG_LOG (0x0401). + + You can have MSG_LOG inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message contains a human-readable payload string from the +device containing errors, warnings and informational messages at +ERROR, WARNING, DEBUG, INFO logging levels. + + + """ + __slots__ = ['level', + 'text', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__level, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__text, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'level' : __level, + 'text' : __text, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.level = res['level'] + self.text = res['text'] + return res, off, length + +SBP_MSG_FWD = 0x0402 +class MsgFwd(SBP): + """SBP class for message MSG_FWD (0x0402). + + You can have MSG_FWD inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message provides the ability to forward messages over SBP. This may take the form +of wrapping up SBP messages received by Piksi for logging purposes or wrapping +another protocol with SBP. + +The source identifier indicates from what interface a forwarded stream derived. +The protocol identifier identifies what the expected protocol the forwarded msg contains. +Protocol 0 represents SBP and the remaining values are implementation defined. + + + """ + __slots__ = ['source', + 'protocol', + 'fwd_payload', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__source, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__protocol, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__fwd_payload, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'source' : __source, + 'protocol' : __protocol, + 'fwd_payload' : __fwd_payload, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.source = res['source'] + self.protocol = res['protocol'] + self.fwd_payload = res['fwd_payload'] + return res, off, length + +SBP_MSG_PRINT_DEP = 0x0010 +class MsgPrintDep(SBP): + """SBP class for message MSG_PRINT_DEP (0x0010). + + You can have MSG_PRINT_DEP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['text', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__text, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'text' : __text, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.text = res['text'] + return res, off, length + + +msg_classes = { + 0x0401: MsgLog, + 0x0402: MsgFwd, + 0x0010: MsgPrintDep, +} \ No newline at end of file diff --git a/python/sbp/jit/mag.py b/python/sbp/jit/mag.py new file mode 100644 index 0000000000..827a36caf8 --- /dev/null +++ b/python/sbp/jit/mag.py @@ -0,0 +1,87 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Magnetometer (mag) messages. +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array + +# Automatically generated from piksi/yaml/swiftnav/sbp/mag.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_MAG_RAW = 0x0902 +class MsgMagRaw(SBP): + """SBP class for message MSG_MAG_RAW (0x0902). + + You can have MSG_MAG_RAW inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Raw data from the magnetometer. + + + """ + __slots__ = ['tow', + 'tow_f', + 'mag_x', + 'mag_y', + 'mag_z', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tow_f, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__mag_x, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__mag_y, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__mag_z, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'tow_f' : __tow_f, + 'mag_x' : __mag_x, + 'mag_y' : __mag_y, + 'mag_z' : __mag_z, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.tow_f = res['tow_f'] + self.mag_x = res['mag_x'] + self.mag_y = res['mag_y'] + self.mag_z = res['mag_z'] + return res, off, length + + +msg_classes = { + 0x0902: MsgMagRaw, +} \ No newline at end of file diff --git a/python/sbp/jit/msg.py b/python/sbp/jit/msg.py new file mode 100644 index 0000000000..d5be94b54c --- /dev/null +++ b/python/sbp/jit/msg.py @@ -0,0 +1,293 @@ +#!/usr/bin/env python + +# Copyright (C) 2019 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +import pybase64 + +import numpy as np +import numba as nb + +import numba.cffi_support + +from sbp.msg import crc16jit +from sbp.msg import SENDER_ID as _SENDER_ID + +from sbp.jit import parse_float_c + + +numba.cffi_support.register_module(parse_float_c) + +_get_f32 = parse_float_c.lib.get_f32 +_get_f64 = parse_float_c.lib.get_f64 + +SENDER_ID = _SENDER_ID + + +@nb.jit('Tuple((u1,u4,u4))(u1[:],u4,u4)', nopython=True, nogil=True) +def get_u8(buf, offset, length): + if length < 1: + return (0, offset, length) + return buf[offset], offset + 1, length - 1 + + +@nb.jit('Tuple((u2,u4,u4))(u1[:],u4,u4)', nopython=True, nogil=True) +def get_u16(buf, offset, length): + if length < 2: + return (0, offset, length) + msb = nb.u2(buf[offset + 1]) << 8 + lsb = nb.u2(buf[offset + 0]) << 0 + return msb | lsb, offset + 2, length - 2 + + +@nb.jit('Tuple((u4,u4,u4))(u1[:],u4,u4)', nopython=True, nogil=True) +def get_u32(buf, offset, length): + if length < 4: + return (0, offset, length) + a = nb.u4(buf[offset + 3]) << 24 + b = nb.u4(buf[offset + 2]) << 16 + c = nb.u4(buf[offset + 1]) << 8 + d = nb.u4(buf[offset + 0]) << 0 + return a | b | c | d, offset + 4, length - 4 + + +@nb.jit('Tuple((u8,u4,u4))(u1[:],u4,u4)', nopython=True, nogil=True) +def get_u64(buf, offset, length): + if length < 8: + return (0, offset, length) + a = nb.u8(buf[offset + 7]) << 54 + b = nb.u8(buf[offset + 6]) << 48 + c = nb.u8(buf[offset + 5]) << 40 + d = nb.u8(buf[offset + 4]) << 32 + e = nb.u8(buf[offset + 3]) << 24 + f = nb.u8(buf[offset + 2]) << 16 + g = nb.u8(buf[offset + 1]) << 8 + h = nb.u8(buf[offset + 0]) << 0 + return a | b | c | d | e | f | g | h, offset + 8, length - 8 + + +@nb.jit('Tuple((i1,u4,u4))(u1[:],u4,u4)', nopython=True, nogil=True) +def get_s8(buf, offset, length): + if length < 1: + return (0, offset, length) + return buf[offset], offset + 1, length - 1 + + +@nb.jit('Tuple((i2,u4,u4))(u1[:],u4,u4)', nopython=True, nogil=True) +def get_s16(buf, offset, length): + if length < 2: + return (0, offset, length) + msb = nb.i2(buf[offset + 1]) << 8 + lsb = nb.i2(buf[offset + 0]) << 0 + return msb | lsb, offset + 2, length - 2 + + +@nb.jit('Tuple((i4,u4,u4))(u1[:],u4,u4)', nopython=True, nogil=True) +def get_s32(buf, offset, length): + if length < 4: + return (0, offset, length) + a = nb.i4(buf[offset + 3]) << 24 + b = nb.i4(buf[offset + 2]) << 16 + c = nb.i4(buf[offset + 1]) << 8 + d = nb.i4(buf[offset + 0]) << 0 + return a | b | c | d, offset + 4, length - 4 + + +@nb.jit('Tuple((i8,u4,u4))(u1[:],u4,u4)', nopython=True, nogil=True) +def get_s64(buf, offset, length): + if length < 8: + return (0, offset, length) + a = nb.i8(buf[offset + 7]) << 54 + b = nb.i8(buf[offset + 6]) << 48 + c = nb.i8(buf[offset + 5]) << 40 + d = nb.i8(buf[offset + 4]) << 32 + e = nb.i8(buf[offset + 3]) << 24 + f = nb.i8(buf[offset + 2]) << 16 + g = nb.i8(buf[offset + 1]) << 8 + h = nb.i8(buf[offset + 0]) << 0 + return a | b | c | d | e | f | g | h, offset + 8, length - 8 + + +@nb.jit('Tuple((f4,u4,u4))(u1[:],u4,u4)', nopython=True, nogil=True) +def get_f32(buf, offset, length): + if length < 4: + return (0, offset, length) + res = _get_f32(buf[offset + 0], + buf[offset + 1], + buf[offset + 2], + buf[offset + 3]) + return res, offset + 4, length - 4 + + +@nb.jit('Tuple((f8,u4,u4))(u1[:],u4,u4)', nopython=True, nogil=True) +def get_f64(buf, offset, length): + if length < 8: + return (0, offset, length) + res = _get_f64(buf[offset + 0], + buf[offset + 1], + buf[offset + 2], + buf[offset + 3], + buf[offset + 4], + buf[offset + 5], + buf[offset + 6], + buf[offset + 7]) + return res, offset + 8, length - 8 + + +@nb.jit('Tuple((u1[:],u4,u4))(u1[:],u4,u4)', nopython=True, nogil=True) +def _get_string(buf_in, offset, length): + buf_out = np.zeros(256, dtype=np.uint8) + i = nb.u4(0) + null_term = False + while i < length: + if buf_in[offset + i] == 0: + null_term = True + break + buf_out[i] = buf_in[offset + i] + i = nb.u4(i + nb.u4(1)) + if null_term: + return buf_out[:i], offset + i + 1, i + 1 + else: + return buf_out[:i], offset + i, i + + +def get_string(buf, offset, length): + buf, offset, length = _get_string(buf, offset, length) + return buf.tobytes(), offset, length + + +def get_fixed_string(size): + def func(buf, offset_in, length): + if length < size: + return '', offset_in, length + buf, offset, length = _get_string(buf, offset_in, size) + return buf.tobytes(), offset_in + size, length + return func + + +def get_array(getter): + def func(buf, offset, length): + arr = [] + while length > 0: + o_1, (res, offset, length) = offset, getter(buf, offset, length) + if o_1 == offset: + return arr, offset, length + arr.append(res) + return arr, offset, length + return func + + +def get_fixed_array(getter, count, el_size): + def func(buf, offset, length): + offset_start = offset + total_size = count * el_size + if length < total_size: + return [], offset_start, 0 + arr = [] + while length > 0: + o_1, (res, offset, length) = offset, getter(buf, offset, length) + if o_1 == offset: + return [], offset_start, 0 + arr.append(res) + length -= el_size + return arr, offset, length-total_size + return func + + +class SBP(object): + """Swift Binary Protocol container. """ + + __slots__ = ['preamble', + 'msg_type', + 'sender', + 'length', + 'payload', + 'crc'] + + def __init__(self, + msg_type=None, + sender=SENDER_ID, + length=None, + payload=None, + crc=None): + self.msg_type = msg_type + self.sender = sender + self.length = length + self.payload = payload + self.crc = crc + + def __eq__(self, other): + try: + if self is other: + return True + elif not isinstance(self, type(other)): + return False + elif self.__slots__ != other.__slots__: + return False + else: + return all(getattr(self, s) == getattr(other, s) + for s in self.__slots__) + except AttributeError: + return False + + @staticmethod + @nb.jit('Tuple((u4, u2, u2, u2, u2, b1))(u1[:], u4, u4)', + nopython=True, nogil=True) + def unpack_payload(buf, offset, length): + crc_fail = False + crc = 0 + pkt_len = 0 + payload_len = 0 + msg_type = 0 + sender = 0 + offset_start = offset + header_len = 6 + if length < header_len: + return (pkt_len, payload_len, msg_type, sender, crc, crc_fail) + preamble, offset, length = get_u8(buf, offset, length) + typ, offset, length = get_u16(buf, offset, length) + sender, offset, length = get_u16(buf, offset, length) + payload_len, offset, length = get_u8(buf, offset, length) + if length < payload_len: + return (pkt_len, payload_len, msg_type, sender, crc, crc_fail) + msg_type = typ + # Consume payload + offset += payload_len + length -= payload_len + crc_len = 2 + if length < crc_len: + return (pkt_len, payload_len, msg_type, sender, crc, crc_fail) + crc, offset, length = get_u16(buf, offset, length) + buf_start = offset_start + 1 + buf_end = offset_start + 1 + (header_len - 1) + payload_len + calc_crc = crc16jit(buf, buf_start, 0, buf_end - buf_start) + if calc_crc != crc: + crc_fail = True + pkt_len = header_len + payload_len + crc_len + return (pkt_len, payload_len, msg_type, sender, crc, crc_fail) + + @classmethod + def parse_members(cls, buf, offset, length): + raise NotImplementedError() + + def _unpack_members(self, buf, offset, length): + raise NotImplementedError() + + def unpack(self, payload, offset, length): + # res, offset, length = {}, offset+length, 0 + res, offset, length = self._unpack_members(payload, offset, length) + if not res: + return res, offset, length + res['msg_type'] = self.msg_type + if self.payload is not None: + res['payload'] = pybase64.encodebytes(self.payload.tobytes()) + res['crc'] = self.crc + res['length'] = self.length + return res, offset, length diff --git a/python/sbp/jit/navigation.py b/python/sbp/jit/navigation.py new file mode 100644 index 0000000000..c3496b40fc --- /dev/null +++ b/python/sbp/jit/navigation.py @@ -0,0 +1,1930 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Geodetic navigation messages reporting GPS time, position, velocity, +and baseline position solutions. For position solutions, these +messages define several different position solutions: single-point +(SPP), RTK, and pseudo-absolute position solutions. + +The SPP is the standalone, absolute GPS position solution using only +a single receiver. The RTK solution is the differential GPS +solution, which can use either a fixed/integer or floating carrier +phase ambiguity. The pseudo-absolute position solution uses a +user-provided, well-surveyed base station position (if available) +and the RTK solution in tandem. + +When the inertial navigation mode indicates that the IMU is used, +all messages are reported in the vehicle body frame as defined by +device settings. By default, the vehicle body frame is configured to be +coincident with the antenna phase center. When there is no inertial +navigation, the solution will be reported at the phase center of the antenna. +There is no inertial navigation capability on Piksi Multi or Duro. + +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array + +# Automatically generated from piksi/yaml/swiftnav/sbp/navigation.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_GPS_TIME = 0x0102 +class MsgGPSTime(SBP): + """SBP class for message MSG_GPS_TIME (0x0102). + + You can have MSG_GPS_TIME inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the GPS time, representing the time since +the GPS epoch began on midnight January 6, 1980 UTC. GPS time +counts the weeks and seconds of the week. The weeks begin at the +Saturday/Sunday transition. GPS week 0 began at the beginning of +the GPS time scale. + +Within each week number, the GPS time of the week is between +between 0 and 604800 seconds (=60*60*24*7). Note that GPS time +does not accumulate leap seconds, and as of now, has a small +offset from UTC. In a message stream, this message precedes a +set of other navigation messages referenced to the same time +(but lacking the ns field) and indicates a more precise time of +these messages. + + + """ + __slots__ = ['wn', + 'tow', + 'ns_residual', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__wn, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ns_residual, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'wn' : __wn, + 'tow' : __tow, + 'ns_residual' : __ns_residual, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.wn = res['wn'] + self.tow = res['tow'] + self.ns_residual = res['ns_residual'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_UTC_TIME = 0x0103 +class MsgUtcTime(SBP): + """SBP class for message MSG_UTC_TIME (0x0103). + + You can have MSG_UTC_TIME inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the Universal Coordinated Time (UTC). Note the flags +which indicate the source of the UTC offset value and source of the time fix. + + + """ + __slots__ = ['flags', + 'tow', + 'year', + 'month', + 'day', + 'hours', + 'minutes', + 'seconds', + 'ns', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__year, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__month, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__day, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__hours, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__minutes, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__seconds, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ns, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'flags' : __flags, + 'tow' : __tow, + 'year' : __year, + 'month' : __month, + 'day' : __day, + 'hours' : __hours, + 'minutes' : __minutes, + 'seconds' : __seconds, + 'ns' : __ns, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.flags = res['flags'] + self.tow = res['tow'] + self.year = res['year'] + self.month = res['month'] + self.day = res['day'] + self.hours = res['hours'] + self.minutes = res['minutes'] + self.seconds = res['seconds'] + self.ns = res['ns'] + return res, off, length + +SBP_MSG_DOPS = 0x0208 +class MsgDops(SBP): + """SBP class for message MSG_DOPS (0x0208). + + You can have MSG_DOPS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This dilution of precision (DOP) message describes the effect of +navigation satellite geometry on positional measurement +precision. The flags field indicated whether the DOP reported +corresponds to differential or SPP solution. + + + """ + __slots__ = ['tow', + 'gdop', + 'pdop', + 'tdop', + 'hdop', + 'vdop', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__gdop, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pdop, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tdop, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__hdop, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__vdop, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'gdop' : __gdop, + 'pdop' : __pdop, + 'tdop' : __tdop, + 'hdop' : __hdop, + 'vdop' : __vdop, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.gdop = res['gdop'] + self.pdop = res['pdop'] + self.tdop = res['tdop'] + self.hdop = res['hdop'] + self.vdop = res['vdop'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_POS_ECEF = 0x0209 +class MsgPosECEF(SBP): + """SBP class for message MSG_POS_ECEF (0x0209). + + You can have MSG_POS_ECEF inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The position solution message reports absolute Earth Centered +Earth Fixed (ECEF) coordinates and the status (single point vs +pseudo-absolute RTK) of the position solution. If the rover +receiver knows the surveyed position of the base station and has +an RTK solution, this reports a pseudo-absolute position +solution using the base station position and the rover's RTK +baseline vector. The full GPS time is given by the preceding +MSG_GPS_TIME with the matching time-of-week (tow). + + + """ + __slots__ = ['tow', + 'x', + 'y', + 'z', + 'accuracy', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__x, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__y, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__z, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'x' : __x, + 'y' : __y, + 'z' : __z, + 'accuracy' : __accuracy, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.x = res['x'] + self.y = res['y'] + self.z = res['z'] + self.accuracy = res['accuracy'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_POS_ECEF_COV = 0x0214 +class MsgPosECEFCov(SBP): + """SBP class for message MSG_POS_ECEF_COV (0x0214). + + You can have MSG_POS_ECEF_COV inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The position solution message reports absolute Earth Centered +Earth Fixed (ECEF) coordinates and the status (single point vs +pseudo-absolute RTK) of the position solution. The message also +reports the upper triangular portion of the 3x3 covariance matrix. +If the receiver knows the surveyed position of the base station and has +an RTK solution, this reports a pseudo-absolute position +solution using the base station position and the rover's RTK +baseline vector. The full GPS time is given by the preceding +MSG_GPS_TIME with the matching time-of-week (tow). + + + """ + __slots__ = ['tow', + 'x', + 'y', + 'z', + 'cov_x_x', + 'cov_x_y', + 'cov_x_z', + 'cov_y_y', + 'cov_y_z', + 'cov_z_z', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__x, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__y, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__z, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_x_x, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_x_y, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_x_z, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_y_y, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_y_z, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_z_z, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'x' : __x, + 'y' : __y, + 'z' : __z, + 'cov_x_x' : __cov_x_x, + 'cov_x_y' : __cov_x_y, + 'cov_x_z' : __cov_x_z, + 'cov_y_y' : __cov_y_y, + 'cov_y_z' : __cov_y_z, + 'cov_z_z' : __cov_z_z, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.x = res['x'] + self.y = res['y'] + self.z = res['z'] + self.cov_x_x = res['cov_x_x'] + self.cov_x_y = res['cov_x_y'] + self.cov_x_z = res['cov_x_z'] + self.cov_y_y = res['cov_y_y'] + self.cov_y_z = res['cov_y_z'] + self.cov_z_z = res['cov_z_z'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_POS_LLH = 0x020A +class MsgPosLLH(SBP): + """SBP class for message MSG_POS_LLH (0x020A). + + You can have MSG_POS_LLH inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This position solution message reports the absolute geodetic +coordinates and the status (single point vs pseudo-absolute RTK) +of the position solution. If the rover receiver knows the +surveyed position of the base station and has an RTK solution, +this reports a pseudo-absolute position solution using the base +station position and the rover's RTK baseline vector. The full +GPS time is given by the preceding MSG_GPS_TIME with the +matching time-of-week (tow). + + + """ + __slots__ = ['tow', + 'lat', + 'lon', + 'height', + 'h_accuracy', + 'v_accuracy', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__lat, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__lon, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__height, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__h_accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__v_accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'lat' : __lat, + 'lon' : __lon, + 'height' : __height, + 'h_accuracy' : __h_accuracy, + 'v_accuracy' : __v_accuracy, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.lat = res['lat'] + self.lon = res['lon'] + self.height = res['height'] + self.h_accuracy = res['h_accuracy'] + self.v_accuracy = res['v_accuracy'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_POS_LLH_COV = 0x0211 +class MsgPosLLHCov(SBP): + """SBP class for message MSG_POS_LLH_COV (0x0211). + + You can have MSG_POS_LLH_COV inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This position solution message reports the absolute geodetic +coordinates and the status (single point vs pseudo-absolute RTK) +of the position solution as well as the upper triangle of the 3x3 +covariance matrix. The position information and Fix Mode flags should +follow the MSG_POS_LLH message. Since the covariance matrix is computed +in the local-level North, East, Down frame, the covariance terms follow +with that convention. Thus, covariances are reported against the "downward" +measurement and care should be taken with the sign convention. + + + """ + __slots__ = ['tow', + 'lat', + 'lon', + 'height', + 'cov_n_n', + 'cov_n_e', + 'cov_n_d', + 'cov_e_e', + 'cov_e_d', + 'cov_d_d', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__lat, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__lon, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__height, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_n_n, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_n_e, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_n_d, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_e_e, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_e_d, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_d_d, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'lat' : __lat, + 'lon' : __lon, + 'height' : __height, + 'cov_n_n' : __cov_n_n, + 'cov_n_e' : __cov_n_e, + 'cov_n_d' : __cov_n_d, + 'cov_e_e' : __cov_e_e, + 'cov_e_d' : __cov_e_d, + 'cov_d_d' : __cov_d_d, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.lat = res['lat'] + self.lon = res['lon'] + self.height = res['height'] + self.cov_n_n = res['cov_n_n'] + self.cov_n_e = res['cov_n_e'] + self.cov_n_d = res['cov_n_d'] + self.cov_e_e = res['cov_e_e'] + self.cov_e_d = res['cov_e_d'] + self.cov_d_d = res['cov_d_d'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_BASELINE_ECEF = 0x020B +class MsgBaselineECEF(SBP): + """SBP class for message MSG_BASELINE_ECEF (0x020B). + + You can have MSG_BASELINE_ECEF inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the baseline solution in Earth Centered +Earth Fixed (ECEF) coordinates. This baseline is the relative +vector distance from the base station to the rover receiver. The +full GPS time is given by the preceding MSG_GPS_TIME with the +matching time-of-week (tow). + + + """ + __slots__ = ['tow', + 'x', + 'y', + 'z', + 'accuracy', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__x, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__y, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__z, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'x' : __x, + 'y' : __y, + 'z' : __z, + 'accuracy' : __accuracy, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.x = res['x'] + self.y = res['y'] + self.z = res['z'] + self.accuracy = res['accuracy'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_BASELINE_NED = 0x020C +class MsgBaselineNED(SBP): + """SBP class for message MSG_BASELINE_NED (0x020C). + + You can have MSG_BASELINE_NED inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the baseline solution in North East Down +(NED) coordinates. This baseline is the relative vector distance +from the base station to the rover receiver, and NED coordinate +system is defined at the local WGS84 tangent plane centered at the +base station position. The full GPS time is given by the +preceding MSG_GPS_TIME with the matching time-of-week (tow). + + + """ + __slots__ = ['tow', + 'n', + 'e', + 'd', + 'h_accuracy', + 'v_accuracy', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__e, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__d, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__h_accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__v_accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'n' : __n, + 'e' : __e, + 'd' : __d, + 'h_accuracy' : __h_accuracy, + 'v_accuracy' : __v_accuracy, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.n = res['n'] + self.e = res['e'] + self.d = res['d'] + self.h_accuracy = res['h_accuracy'] + self.v_accuracy = res['v_accuracy'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_VEL_ECEF = 0x020D +class MsgVelECEF(SBP): + """SBP class for message MSG_VEL_ECEF (0x020D). + + You can have MSG_VEL_ECEF inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the velocity in Earth Centered Earth Fixed +(ECEF) coordinates. The full GPS time is given by the preceding +MSG_GPS_TIME with the matching time-of-week (tow). + + + """ + __slots__ = ['tow', + 'x', + 'y', + 'z', + 'accuracy', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__x, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__y, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__z, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'x' : __x, + 'y' : __y, + 'z' : __z, + 'accuracy' : __accuracy, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.x = res['x'] + self.y = res['y'] + self.z = res['z'] + self.accuracy = res['accuracy'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_VEL_ECEF_COV = 0x0215 +class MsgVelECEFCov(SBP): + """SBP class for message MSG_VEL_ECEF_COV (0x0215). + + You can have MSG_VEL_ECEF_COV inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the velocity in Earth Centered Earth Fixed +(ECEF) coordinates. The full GPS time is given by the preceding +MSG_GPS_TIME with the matching time-of-week (tow). + + + """ + __slots__ = ['tow', + 'x', + 'y', + 'z', + 'cov_x_x', + 'cov_x_y', + 'cov_x_z', + 'cov_y_y', + 'cov_y_z', + 'cov_z_z', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__x, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__y, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__z, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_x_x, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_x_y, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_x_z, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_y_y, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_y_z, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_z_z, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'x' : __x, + 'y' : __y, + 'z' : __z, + 'cov_x_x' : __cov_x_x, + 'cov_x_y' : __cov_x_y, + 'cov_x_z' : __cov_x_z, + 'cov_y_y' : __cov_y_y, + 'cov_y_z' : __cov_y_z, + 'cov_z_z' : __cov_z_z, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.x = res['x'] + self.y = res['y'] + self.z = res['z'] + self.cov_x_x = res['cov_x_x'] + self.cov_x_y = res['cov_x_y'] + self.cov_x_z = res['cov_x_z'] + self.cov_y_y = res['cov_y_y'] + self.cov_y_z = res['cov_y_z'] + self.cov_z_z = res['cov_z_z'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_VEL_NED = 0x020E +class MsgVelNED(SBP): + """SBP class for message MSG_VEL_NED (0x020E). + + You can have MSG_VEL_NED inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the velocity in local North East Down (NED) +coordinates. The NED coordinate system is defined as the local WGS84 +tangent plane centered at the current position. The full GPS time is +given by the preceding MSG_GPS_TIME with the matching time-of-week (tow). + + + """ + __slots__ = ['tow', + 'n', + 'e', + 'd', + 'h_accuracy', + 'v_accuracy', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__e, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__d, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__h_accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__v_accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'n' : __n, + 'e' : __e, + 'd' : __d, + 'h_accuracy' : __h_accuracy, + 'v_accuracy' : __v_accuracy, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.n = res['n'] + self.e = res['e'] + self.d = res['d'] + self.h_accuracy = res['h_accuracy'] + self.v_accuracy = res['v_accuracy'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_VEL_NED_COV = 0x0212 +class MsgVelNEDCov(SBP): + """SBP class for message MSG_VEL_NED_COV (0x0212). + + You can have MSG_VEL_NED_COV inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the velocity in local North East Down (NED) +coordinates. The NED coordinate system is defined as the local WGS84 +tangent plane centered at the current position. The full GPS time is +given by the preceding MSG_GPS_TIME with the matching time-of-week (tow). +This message is similar to the MSG_VEL_NED, but it includes the upper triangular +portion of the 3x3 covariance matrix. + + + """ + __slots__ = ['tow', + 'n', + 'e', + 'd', + 'cov_n_n', + 'cov_n_e', + 'cov_n_d', + 'cov_e_e', + 'cov_e_d', + 'cov_d_d', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__e, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__d, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_n_n, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_n_e, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_n_d, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_e_e, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_e_d, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_d_d, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'n' : __n, + 'e' : __e, + 'd' : __d, + 'cov_n_n' : __cov_n_n, + 'cov_n_e' : __cov_n_e, + 'cov_n_d' : __cov_n_d, + 'cov_e_e' : __cov_e_e, + 'cov_e_d' : __cov_e_d, + 'cov_d_d' : __cov_d_d, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.n = res['n'] + self.e = res['e'] + self.d = res['d'] + self.cov_n_n = res['cov_n_n'] + self.cov_n_e = res['cov_n_e'] + self.cov_n_d = res['cov_n_d'] + self.cov_e_e = res['cov_e_e'] + self.cov_e_d = res['cov_e_d'] + self.cov_d_d = res['cov_d_d'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_VEL_BODY = 0x0213 +class MsgVelBody(SBP): + """SBP class for message MSG_VEL_BODY (0x0213). + + You can have MSG_VEL_BODY inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the velocity in the Vehicle Body Frame. By convention, +the x-axis should point out the nose of the vehicle and represent the forward +direction, while as the y-axis should point out the right hand side of the vehicle. +Since this is a right handed system, z should point out the bottom of the vehicle. +The orientation and origin of the Vehicle Body Frame are specified via the device settings. +The full GPS time is given by the preceding MSG_GPS_TIME with the +matching time-of-week (tow). This message is only produced by inertial versions of Swift +products and is not available from Piksi Multi or Duro. + + + """ + __slots__ = ['tow', + 'x', + 'y', + 'z', + 'cov_x_x', + 'cov_x_y', + 'cov_x_z', + 'cov_y_y', + 'cov_y_z', + 'cov_z_z', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__x, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__y, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__z, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_x_x, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_x_y, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_x_z, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_y_y, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_y_z, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cov_z_z, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'x' : __x, + 'y' : __y, + 'z' : __z, + 'cov_x_x' : __cov_x_x, + 'cov_x_y' : __cov_x_y, + 'cov_x_z' : __cov_x_z, + 'cov_y_y' : __cov_y_y, + 'cov_y_z' : __cov_y_z, + 'cov_z_z' : __cov_z_z, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.x = res['x'] + self.y = res['y'] + self.z = res['z'] + self.cov_x_x = res['cov_x_x'] + self.cov_x_y = res['cov_x_y'] + self.cov_x_z = res['cov_x_z'] + self.cov_y_y = res['cov_y_y'] + self.cov_y_z = res['cov_y_z'] + self.cov_z_z = res['cov_z_z'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_AGE_CORRECTIONS = 0x0210 +class MsgAgeCorrections(SBP): + """SBP class for message MSG_AGE_CORRECTIONS (0x0210). + + You can have MSG_AGE_CORRECTIONS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the Age of the corrections used for the current +Differential solution + + + """ + __slots__ = ['tow', + 'age', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__age, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'age' : __age, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.age = res['age'] + return res, off, length + +SBP_MSG_GPS_TIME_DEP_A = 0x0100 +class MsgGPSTimeDepA(SBP): + """SBP class for message MSG_GPS_TIME_DEP_A (0x0100). + + You can have MSG_GPS_TIME_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the GPS time, representing the time since +the GPS epoch began on midnight January 6, 1980 UTC. GPS time +counts the weeks and seconds of the week. The weeks begin at the +Saturday/Sunday transition. GPS week 0 began at the beginning of +the GPS time scale. + +Within each week number, the GPS time of the week is between +between 0 and 604800 seconds (=60*60*24*7). Note that GPS time +does not accumulate leap seconds, and as of now, has a small +offset from UTC. In a message stream, this message precedes a +set of other navigation messages referenced to the same time +(but lacking the ns field) and indicates a more precise time of +these messages. + + + """ + __slots__ = ['wn', + 'tow', + 'ns_residual', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__wn, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ns_residual, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'wn' : __wn, + 'tow' : __tow, + 'ns_residual' : __ns_residual, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.wn = res['wn'] + self.tow = res['tow'] + self.ns_residual = res['ns_residual'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_DOPS_DEP_A = 0x0206 +class MsgDopsDepA(SBP): + """SBP class for message MSG_DOPS_DEP_A (0x0206). + + You can have MSG_DOPS_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This dilution of precision (DOP) message describes the effect of +navigation satellite geometry on positional measurement +precision. + + + """ + __slots__ = ['tow', + 'gdop', + 'pdop', + 'tdop', + 'hdop', + 'vdop', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__gdop, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pdop, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tdop, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__hdop, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__vdop, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'gdop' : __gdop, + 'pdop' : __pdop, + 'tdop' : __tdop, + 'hdop' : __hdop, + 'vdop' : __vdop, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.gdop = res['gdop'] + self.pdop = res['pdop'] + self.tdop = res['tdop'] + self.hdop = res['hdop'] + self.vdop = res['vdop'] + return res, off, length + +SBP_MSG_POS_ECEF_DEP_A = 0x0200 +class MsgPosECEFDepA(SBP): + """SBP class for message MSG_POS_ECEF_DEP_A (0x0200). + + You can have MSG_POS_ECEF_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The position solution message reports absolute Earth Centered +Earth Fixed (ECEF) coordinates and the status (single point vs +pseudo-absolute RTK) of the position solution. If the rover +receiver knows the surveyed position of the base station and has +an RTK solution, this reports a pseudo-absolute position +solution using the base station position and the rover's RTK +baseline vector. The full GPS time is given by the preceding +MSG_GPS_TIME with the matching time-of-week (tow). + + + """ + __slots__ = ['tow', + 'x', + 'y', + 'z', + 'accuracy', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__x, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__y, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__z, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'x' : __x, + 'y' : __y, + 'z' : __z, + 'accuracy' : __accuracy, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.x = res['x'] + self.y = res['y'] + self.z = res['z'] + self.accuracy = res['accuracy'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_POS_LLH_DEP_A = 0x0201 +class MsgPosLLHDepA(SBP): + """SBP class for message MSG_POS_LLH_DEP_A (0x0201). + + You can have MSG_POS_LLH_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This position solution message reports the absolute geodetic +coordinates and the status (single point vs pseudo-absolute RTK) +of the position solution. If the rover receiver knows the +surveyed position of the base station and has an RTK solution, +this reports a pseudo-absolute position solution using the base +station position and the rover's RTK baseline vector. The full +GPS time is given by the preceding MSG_GPS_TIME with the +matching time-of-week (tow). + + + """ + __slots__ = ['tow', + 'lat', + 'lon', + 'height', + 'h_accuracy', + 'v_accuracy', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__lat, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__lon, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__height, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__h_accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__v_accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'lat' : __lat, + 'lon' : __lon, + 'height' : __height, + 'h_accuracy' : __h_accuracy, + 'v_accuracy' : __v_accuracy, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.lat = res['lat'] + self.lon = res['lon'] + self.height = res['height'] + self.h_accuracy = res['h_accuracy'] + self.v_accuracy = res['v_accuracy'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_BASELINE_ECEF_DEP_A = 0x0202 +class MsgBaselineECEFDepA(SBP): + """SBP class for message MSG_BASELINE_ECEF_DEP_A (0x0202). + + You can have MSG_BASELINE_ECEF_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the baseline solution in Earth Centered +Earth Fixed (ECEF) coordinates. This baseline is the relative +vector distance from the base station to the rover receiver. The +full GPS time is given by the preceding MSG_GPS_TIME with the +matching time-of-week (tow). + + + """ + __slots__ = ['tow', + 'x', + 'y', + 'z', + 'accuracy', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__x, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__y, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__z, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'x' : __x, + 'y' : __y, + 'z' : __z, + 'accuracy' : __accuracy, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.x = res['x'] + self.y = res['y'] + self.z = res['z'] + self.accuracy = res['accuracy'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_BASELINE_NED_DEP_A = 0x0203 +class MsgBaselineNEDDepA(SBP): + """SBP class for message MSG_BASELINE_NED_DEP_A (0x0203). + + You can have MSG_BASELINE_NED_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the baseline solution in North East Down +(NED) coordinates. This baseline is the relative vector distance +from the base station to the rover receiver, and NED coordinate +system is defined at the local WGS84 tangent plane centered at the +base station position. The full GPS time is given by the +preceding MSG_GPS_TIME with the matching time-of-week (tow). + + + """ + __slots__ = ['tow', + 'n', + 'e', + 'd', + 'h_accuracy', + 'v_accuracy', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__e, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__d, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__h_accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__v_accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'n' : __n, + 'e' : __e, + 'd' : __d, + 'h_accuracy' : __h_accuracy, + 'v_accuracy' : __v_accuracy, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.n = res['n'] + self.e = res['e'] + self.d = res['d'] + self.h_accuracy = res['h_accuracy'] + self.v_accuracy = res['v_accuracy'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_VEL_ECEF_DEP_A = 0x0204 +class MsgVelECEFDepA(SBP): + """SBP class for message MSG_VEL_ECEF_DEP_A (0x0204). + + You can have MSG_VEL_ECEF_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the velocity in Earth Centered Earth Fixed +(ECEF) coordinates. The full GPS time is given by the preceding +MSG_GPS_TIME with the matching time-of-week (tow). + + + """ + __slots__ = ['tow', + 'x', + 'y', + 'z', + 'accuracy', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__x, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__y, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__z, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'x' : __x, + 'y' : __y, + 'z' : __z, + 'accuracy' : __accuracy, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.x = res['x'] + self.y = res['y'] + self.z = res['z'] + self.accuracy = res['accuracy'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_VEL_NED_DEP_A = 0x0205 +class MsgVelNEDDepA(SBP): + """SBP class for message MSG_VEL_NED_DEP_A (0x0205). + + You can have MSG_VEL_NED_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the velocity in local North East Down (NED) +coordinates. The NED coordinate system is defined as the local WGS84 +tangent plane centered at the current position. The full GPS time is +given by the preceding MSG_GPS_TIME with the matching time-of-week (tow). + + + """ + __slots__ = ['tow', + 'n', + 'e', + 'd', + 'h_accuracy', + 'v_accuracy', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__e, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__d, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__h_accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__v_accuracy, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'n' : __n, + 'e' : __e, + 'd' : __d, + 'h_accuracy' : __h_accuracy, + 'v_accuracy' : __v_accuracy, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.n = res['n'] + self.e = res['e'] + self.d = res['d'] + self.h_accuracy = res['h_accuracy'] + self.v_accuracy = res['v_accuracy'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_BASELINE_HEADING_DEP_A = 0x0207 +class MsgBaselineHeadingDepA(SBP): + """SBP class for message MSG_BASELINE_HEADING_DEP_A (0x0207). + + You can have MSG_BASELINE_HEADING_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the baseline heading pointing from the base station +to the rover relative to True North. The full GPS time is given by the +preceding MSG_GPS_TIME with the matching time-of-week (tow). + + + """ + __slots__ = ['tow', + 'heading', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__heading, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'heading' : __heading, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.heading = res['heading'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + + +msg_classes = { + 0x0102: MsgGPSTime, + 0x0103: MsgUtcTime, + 0x0208: MsgDops, + 0x0209: MsgPosECEF, + 0x0214: MsgPosECEFCov, + 0x020A: MsgPosLLH, + 0x0211: MsgPosLLHCov, + 0x020B: MsgBaselineECEF, + 0x020C: MsgBaselineNED, + 0x020D: MsgVelECEF, + 0x0215: MsgVelECEFCov, + 0x020E: MsgVelNED, + 0x0212: MsgVelNEDCov, + 0x0213: MsgVelBody, + 0x0210: MsgAgeCorrections, + 0x0100: MsgGPSTimeDepA, + 0x0206: MsgDopsDepA, + 0x0200: MsgPosECEFDepA, + 0x0201: MsgPosLLHDepA, + 0x0202: MsgBaselineECEFDepA, + 0x0203: MsgBaselineNEDDepA, + 0x0204: MsgVelECEFDepA, + 0x0205: MsgVelNEDDepA, + 0x0207: MsgBaselineHeadingDepA, +} \ No newline at end of file diff --git a/python/sbp/jit/ndb.py b/python/sbp/jit/ndb.py new file mode 100644 index 0000000000..aefbe066f8 --- /dev/null +++ b/python/sbp/jit/ndb.py @@ -0,0 +1,108 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Messages for logging NDB events. + +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array +from sbp.jit.gnss import * + +# Automatically generated from piksi/yaml/swiftnav/sbp/ndb.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_NDB_EVENT = 0x0400 +class MsgNdbEvent(SBP): + """SBP class for message MSG_NDB_EVENT (0x0400). + + You can have MSG_NDB_EVENT inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message is sent out when an object is stored into NDB. If needed +message could also be sent out when fetching an object from NDB. + + + """ + __slots__ = ['recv_time', + 'event', + 'object_type', + 'result', + 'data_source', + 'object_sid', + 'src_sid', + 'original_sender', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__recv_time, offset, length) = offset, get_u64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__event, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__object_type, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__result, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__data_source, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__object_sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__src_sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__original_sender, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'recv_time' : __recv_time, + 'event' : __event, + 'object_type' : __object_type, + 'result' : __result, + 'data_source' : __data_source, + 'object_sid' : __object_sid, + 'src_sid' : __src_sid, + 'original_sender' : __original_sender, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.recv_time = res['recv_time'] + self.event = res['event'] + self.object_type = res['object_type'] + self.result = res['result'] + self.data_source = res['data_source'] + self.object_sid = res['object_sid'] + self.src_sid = res['src_sid'] + self.original_sender = res['original_sender'] + return res, off, length + + +msg_classes = { + 0x0400: MsgNdbEvent, +} \ No newline at end of file diff --git a/python/sbp/jit/observation.py b/python/sbp/jit/observation.py new file mode 100644 index 0000000000..01691f0d41 --- /dev/null +++ b/python/sbp/jit/observation.py @@ -0,0 +1,4042 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Satellite observation messages from the device. +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array +from sbp.jit.gnss import * + +# Automatically generated from piksi/yaml/swiftnav/sbp/observation.yaml with generate.py. +# Please do not hand edit! +class ObservationHeader(object): + """SBP class for message ObservationHeader + + You can have ObservationHeader inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Header of a GNSS observation message. + + """ + __slots__ = ['t', + 'n_obs', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__t, offset, length) = offset, GPSTime.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_obs, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 't' : __t, + 'n_obs' : __n_obs, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.t = res['t'] + self.n_obs = res['n_obs'] + return res, off, length + +class Doppler(object): + """SBP class for message Doppler + + You can have Doppler inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Doppler measurement in Hz represented as a 24-bit +fixed point number with Q16.8 layout, i.e. 16-bits of whole +doppler and 8-bits of fractional doppler. This doppler is defined +as positive for approaching satellites. + + + """ + __slots__ = ['i', + 'f', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__i, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__f, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'i' : __i, + 'f' : __f, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.i = res['i'] + self.f = res['f'] + return res, off, length + +class PackedObsContent(object): + """SBP class for message PackedObsContent + + You can have PackedObsContent inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Pseudorange and carrier phase observation for a satellite being tracked. +The observations are interoperable with 3rd party receivers and conform with +typical RTCM 3.1 message GPS/GLO observations. + +Carrier phase observations are not guaranteed to be aligned to the RINEX 3 +or RTCM 3.3 MSM reference signal and no 1/4 cycle adjustments are currently +peformed. + + + """ + __slots__ = ['P', + 'L', + 'D', + 'cn0', + 'lock', + 'flags', + 'sid', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__P, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__L, offset, length) = offset, CarrierPhase.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__D, offset, length) = offset, Doppler.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cn0, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__lock, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'P' : __P, + 'L' : __L, + 'D' : __D, + 'cn0' : __cn0, + 'lock' : __lock, + 'flags' : __flags, + 'sid' : __sid, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.P = res['P'] + self.L = res['L'] + self.D = res['D'] + self.cn0 = res['cn0'] + self.lock = res['lock'] + self.flags = res['flags'] + self.sid = res['sid'] + return res, off, length + +SBP_MSG_OBS = 0x004A +class MsgObs(SBP): + """SBP class for message MSG_OBS (0x004A). + + You can have MSG_OBS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The GPS observations message reports all the raw pseudorange and +carrier phase observations for the satellites being tracked by +the device. Carrier phase observation here is represented as a +40-bit fixed point number with Q32.8 layout (i.e. 32-bits of +whole cycles and 8-bits of fractional cycles). The observations +are be interoperable with 3rd party receivers and conform +with typical RTCMv3 GNSS observations. + + + """ + __slots__ = ['header', + 'obs', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__header, offset, length) = offset, ObservationHeader.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__obs, offset, length) = offset, get_array(PackedObsContent.parse_members)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'header' : __header, + 'obs' : __obs, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.header = res['header'] + self.obs = res['obs'] + return res, off, length + +SBP_MSG_BASE_POS_LLH = 0x0044 +class MsgBasePosLLH(SBP): + """SBP class for message MSG_BASE_POS_LLH (0x0044). + + You can have MSG_BASE_POS_LLH inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The base station position message is the position reported by +the base station itself. It is used for pseudo-absolute RTK +positioning, and is required to be a high-accuracy surveyed +location of the base station. Any error here will result in an +error in the pseudo-absolute position output. + + + """ + __slots__ = ['lat', + 'lon', + 'height', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__lat, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__lon, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__height, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'lat' : __lat, + 'lon' : __lon, + 'height' : __height, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.lat = res['lat'] + self.lon = res['lon'] + self.height = res['height'] + return res, off, length + +SBP_MSG_BASE_POS_ECEF = 0x0048 +class MsgBasePosECEF(SBP): + """SBP class for message MSG_BASE_POS_ECEF (0x0048). + + You can have MSG_BASE_POS_ECEF inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The base station position message is the position reported by +the base station itself in absolute Earth Centered Earth Fixed +coordinates. It is used for pseudo-absolute RTK positioning, and +is required to be a high-accuracy surveyed location of the base +station. Any error here will result in an error in the +pseudo-absolute position output. + + + """ + __slots__ = ['x', + 'y', + 'z', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__x, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__y, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__z, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'x' : __x, + 'y' : __y, + 'z' : __z, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.x = res['x'] + self.y = res['y'] + self.z = res['z'] + return res, off, length + +class EphemerisCommonContent(object): + """SBP class for message EphemerisCommonContent + + You can have EphemerisCommonContent inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + """ + __slots__ = ['sid', + 'toe', + 'ura', + 'fit_interval', + 'valid', + 'health_bits', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toe, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ura, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__fit_interval, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__health_bits, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sid' : __sid, + 'toe' : __toe, + 'ura' : __ura, + 'fit_interval' : __fit_interval, + 'valid' : __valid, + 'health_bits' : __health_bits, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sid = res['sid'] + self.toe = res['toe'] + self.ura = res['ura'] + self.fit_interval = res['fit_interval'] + self.valid = res['valid'] + self.health_bits = res['health_bits'] + return res, off, length + +class EphemerisCommonContentDepB(object): + """SBP class for message EphemerisCommonContentDepB + + You can have EphemerisCommonContentDepB inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + """ + __slots__ = ['sid', + 'toe', + 'ura', + 'fit_interval', + 'valid', + 'health_bits', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toe, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ura, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__fit_interval, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__health_bits, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sid' : __sid, + 'toe' : __toe, + 'ura' : __ura, + 'fit_interval' : __fit_interval, + 'valid' : __valid, + 'health_bits' : __health_bits, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sid = res['sid'] + self.toe = res['toe'] + self.ura = res['ura'] + self.fit_interval = res['fit_interval'] + self.valid = res['valid'] + self.health_bits = res['health_bits'] + return res, off, length + +class EphemerisCommonContentDepA(object): + """SBP class for message EphemerisCommonContentDepA + + You can have EphemerisCommonContentDepA inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + """ + __slots__ = ['sid', + 'toe', + 'ura', + 'fit_interval', + 'valid', + 'health_bits', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toe, offset, length) = offset, GPSTimeDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ura, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__fit_interval, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__health_bits, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sid' : __sid, + 'toe' : __toe, + 'ura' : __ura, + 'fit_interval' : __fit_interval, + 'valid' : __valid, + 'health_bits' : __health_bits, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sid = res['sid'] + self.toe = res['toe'] + self.ura = res['ura'] + self.fit_interval = res['fit_interval'] + self.valid = res['valid'] + self.health_bits = res['health_bits'] + return res, off, length + +SBP_MSG_EPHEMERIS_GPS_DEP_E = 0x0081 +class MsgEphemerisGPSDepE(SBP): + """SBP class for message MSG_EPHEMERIS_GPS_DEP_E (0x0081). + + You can have MSG_EPHEMERIS_GPS_DEP_E inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The ephemeris message returns a set of satellite orbit +parameters that is used to calculate GPS satellite position, +velocity, and clock offset. Please see the Navstar GPS +Space Segment/Navigation user interfaces (ICD-GPS-200, Table +20-III) for more details. + + + """ + __slots__ = ['common', + 'tgd', + 'c_rs', + 'c_rc', + 'c_uc', + 'c_us', + 'c_ic', + 'c_is', + 'dn', + 'm0', + 'ecc', + 'sqrta', + 'omega0', + 'omegadot', + 'w', + 'inc', + 'inc_dot', + 'af0', + 'af1', + 'af2', + 'toc', + 'iode', + 'iodc', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__common, offset, length) = offset, EphemerisCommonContentDepA.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tgd, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rs, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_uc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_us, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_ic, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_is, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af2, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toc, offset, length) = offset, GPSTimeDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iode, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iodc, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'common' : __common, + 'tgd' : __tgd, + 'c_rs' : __c_rs, + 'c_rc' : __c_rc, + 'c_uc' : __c_uc, + 'c_us' : __c_us, + 'c_ic' : __c_ic, + 'c_is' : __c_is, + 'dn' : __dn, + 'm0' : __m0, + 'ecc' : __ecc, + 'sqrta' : __sqrta, + 'omega0' : __omega0, + 'omegadot' : __omegadot, + 'w' : __w, + 'inc' : __inc, + 'inc_dot' : __inc_dot, + 'af0' : __af0, + 'af1' : __af1, + 'af2' : __af2, + 'toc' : __toc, + 'iode' : __iode, + 'iodc' : __iodc, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.common = res['common'] + self.tgd = res['tgd'] + self.c_rs = res['c_rs'] + self.c_rc = res['c_rc'] + self.c_uc = res['c_uc'] + self.c_us = res['c_us'] + self.c_ic = res['c_ic'] + self.c_is = res['c_is'] + self.dn = res['dn'] + self.m0 = res['m0'] + self.ecc = res['ecc'] + self.sqrta = res['sqrta'] + self.omega0 = res['omega0'] + self.omegadot = res['omegadot'] + self.w = res['w'] + self.inc = res['inc'] + self.inc_dot = res['inc_dot'] + self.af0 = res['af0'] + self.af1 = res['af1'] + self.af2 = res['af2'] + self.toc = res['toc'] + self.iode = res['iode'] + self.iodc = res['iodc'] + return res, off, length + +SBP_MSG_EPHEMERIS_GPS_DEP_F = 0x0086 +class MsgEphemerisGPSDepF(SBP): + """SBP class for message MSG_EPHEMERIS_GPS_DEP_F (0x0086). + + You can have MSG_EPHEMERIS_GPS_DEP_F inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This observation message has been deprecated in favor of +ephemeris message using floats for size reduction. + + + """ + __slots__ = ['common', + 'tgd', + 'c_rs', + 'c_rc', + 'c_uc', + 'c_us', + 'c_ic', + 'c_is', + 'dn', + 'm0', + 'ecc', + 'sqrta', + 'omega0', + 'omegadot', + 'w', + 'inc', + 'inc_dot', + 'af0', + 'af1', + 'af2', + 'toc', + 'iode', + 'iodc', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__common, offset, length) = offset, EphemerisCommonContentDepB.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tgd, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rs, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_uc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_us, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_ic, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_is, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af2, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toc, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iode, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iodc, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'common' : __common, + 'tgd' : __tgd, + 'c_rs' : __c_rs, + 'c_rc' : __c_rc, + 'c_uc' : __c_uc, + 'c_us' : __c_us, + 'c_ic' : __c_ic, + 'c_is' : __c_is, + 'dn' : __dn, + 'm0' : __m0, + 'ecc' : __ecc, + 'sqrta' : __sqrta, + 'omega0' : __omega0, + 'omegadot' : __omegadot, + 'w' : __w, + 'inc' : __inc, + 'inc_dot' : __inc_dot, + 'af0' : __af0, + 'af1' : __af1, + 'af2' : __af2, + 'toc' : __toc, + 'iode' : __iode, + 'iodc' : __iodc, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.common = res['common'] + self.tgd = res['tgd'] + self.c_rs = res['c_rs'] + self.c_rc = res['c_rc'] + self.c_uc = res['c_uc'] + self.c_us = res['c_us'] + self.c_ic = res['c_ic'] + self.c_is = res['c_is'] + self.dn = res['dn'] + self.m0 = res['m0'] + self.ecc = res['ecc'] + self.sqrta = res['sqrta'] + self.omega0 = res['omega0'] + self.omegadot = res['omegadot'] + self.w = res['w'] + self.inc = res['inc'] + self.inc_dot = res['inc_dot'] + self.af0 = res['af0'] + self.af1 = res['af1'] + self.af2 = res['af2'] + self.toc = res['toc'] + self.iode = res['iode'] + self.iodc = res['iodc'] + return res, off, length + +SBP_MSG_EPHEMERIS_GPS = 0x008A +class MsgEphemerisGPS(SBP): + """SBP class for message MSG_EPHEMERIS_GPS (0x008A). + + You can have MSG_EPHEMERIS_GPS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The ephemeris message returns a set of satellite orbit +parameters that is used to calculate GPS satellite position, +velocity, and clock offset. Please see the Navstar GPS +Space Segment/Navigation user interfaces (ICD-GPS-200, Table +20-III) for more details. + + + """ + __slots__ = ['common', + 'tgd', + 'c_rs', + 'c_rc', + 'c_uc', + 'c_us', + 'c_ic', + 'c_is', + 'dn', + 'm0', + 'ecc', + 'sqrta', + 'omega0', + 'omegadot', + 'w', + 'inc', + 'inc_dot', + 'af0', + 'af1', + 'af2', + 'toc', + 'iode', + 'iodc', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__common, offset, length) = offset, EphemerisCommonContent.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tgd, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rs, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rc, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_uc, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_us, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_ic, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_is, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af0, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af1, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af2, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toc, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iode, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iodc, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'common' : __common, + 'tgd' : __tgd, + 'c_rs' : __c_rs, + 'c_rc' : __c_rc, + 'c_uc' : __c_uc, + 'c_us' : __c_us, + 'c_ic' : __c_ic, + 'c_is' : __c_is, + 'dn' : __dn, + 'm0' : __m0, + 'ecc' : __ecc, + 'sqrta' : __sqrta, + 'omega0' : __omega0, + 'omegadot' : __omegadot, + 'w' : __w, + 'inc' : __inc, + 'inc_dot' : __inc_dot, + 'af0' : __af0, + 'af1' : __af1, + 'af2' : __af2, + 'toc' : __toc, + 'iode' : __iode, + 'iodc' : __iodc, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.common = res['common'] + self.tgd = res['tgd'] + self.c_rs = res['c_rs'] + self.c_rc = res['c_rc'] + self.c_uc = res['c_uc'] + self.c_us = res['c_us'] + self.c_ic = res['c_ic'] + self.c_is = res['c_is'] + self.dn = res['dn'] + self.m0 = res['m0'] + self.ecc = res['ecc'] + self.sqrta = res['sqrta'] + self.omega0 = res['omega0'] + self.omegadot = res['omegadot'] + self.w = res['w'] + self.inc = res['inc'] + self.inc_dot = res['inc_dot'] + self.af0 = res['af0'] + self.af1 = res['af1'] + self.af2 = res['af2'] + self.toc = res['toc'] + self.iode = res['iode'] + self.iodc = res['iodc'] + return res, off, length + +SBP_MSG_EPHEMERIS_BDS = 0x0089 +class MsgEphemerisBds(SBP): + """SBP class for message MSG_EPHEMERIS_BDS (0x0089). + + You can have MSG_EPHEMERIS_BDS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The ephemeris message returns a set of satellite orbit +parameters that is used to calculate BDS satellite position, +velocity, and clock offset. Please see the BeiDou Navigation +Satellite System SIS-ICD Version 2.1, Table 5-9 for more details. + + + """ + __slots__ = ['common', + 'tgd1', + 'tgd2', + 'c_rs', + 'c_rc', + 'c_uc', + 'c_us', + 'c_ic', + 'c_is', + 'dn', + 'm0', + 'ecc', + 'sqrta', + 'omega0', + 'omegadot', + 'w', + 'inc', + 'inc_dot', + 'af0', + 'af1', + 'af2', + 'toc', + 'iode', + 'iodc', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__common, offset, length) = offset, EphemerisCommonContent.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tgd1, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tgd2, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rs, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rc, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_uc, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_us, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_ic, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_is, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af1, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af2, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toc, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iode, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iodc, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'common' : __common, + 'tgd1' : __tgd1, + 'tgd2' : __tgd2, + 'c_rs' : __c_rs, + 'c_rc' : __c_rc, + 'c_uc' : __c_uc, + 'c_us' : __c_us, + 'c_ic' : __c_ic, + 'c_is' : __c_is, + 'dn' : __dn, + 'm0' : __m0, + 'ecc' : __ecc, + 'sqrta' : __sqrta, + 'omega0' : __omega0, + 'omegadot' : __omegadot, + 'w' : __w, + 'inc' : __inc, + 'inc_dot' : __inc_dot, + 'af0' : __af0, + 'af1' : __af1, + 'af2' : __af2, + 'toc' : __toc, + 'iode' : __iode, + 'iodc' : __iodc, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.common = res['common'] + self.tgd1 = res['tgd1'] + self.tgd2 = res['tgd2'] + self.c_rs = res['c_rs'] + self.c_rc = res['c_rc'] + self.c_uc = res['c_uc'] + self.c_us = res['c_us'] + self.c_ic = res['c_ic'] + self.c_is = res['c_is'] + self.dn = res['dn'] + self.m0 = res['m0'] + self.ecc = res['ecc'] + self.sqrta = res['sqrta'] + self.omega0 = res['omega0'] + self.omegadot = res['omegadot'] + self.w = res['w'] + self.inc = res['inc'] + self.inc_dot = res['inc_dot'] + self.af0 = res['af0'] + self.af1 = res['af1'] + self.af2 = res['af2'] + self.toc = res['toc'] + self.iode = res['iode'] + self.iodc = res['iodc'] + return res, off, length + +SBP_MSG_EPHEMERIS_GAL = 0x0095 +class MsgEphemerisGal(SBP): + """SBP class for message MSG_EPHEMERIS_GAL (0x0095). + + You can have MSG_EPHEMERIS_GAL inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The ephemeris message returns a set of satellite orbit +parameters that is used to calculate Galileo satellite position, +velocity, and clock offset. Please see the Signal In Space ICD +OS SIS ICD, Issue 1.3, December 2016 for more details. + + + """ + __slots__ = ['common', + 'bgd_e1e5a', + 'bgd_e1e5b', + 'c_rs', + 'c_rc', + 'c_uc', + 'c_us', + 'c_ic', + 'c_is', + 'dn', + 'm0', + 'ecc', + 'sqrta', + 'omega0', + 'omegadot', + 'w', + 'inc', + 'inc_dot', + 'af0', + 'af1', + 'af2', + 'toc', + 'iode', + 'iodc', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__common, offset, length) = offset, EphemerisCommonContent.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__bgd_e1e5a, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__bgd_e1e5b, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rs, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rc, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_uc, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_us, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_ic, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_is, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af2, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toc, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iode, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iodc, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'common' : __common, + 'bgd_e1e5a' : __bgd_e1e5a, + 'bgd_e1e5b' : __bgd_e1e5b, + 'c_rs' : __c_rs, + 'c_rc' : __c_rc, + 'c_uc' : __c_uc, + 'c_us' : __c_us, + 'c_ic' : __c_ic, + 'c_is' : __c_is, + 'dn' : __dn, + 'm0' : __m0, + 'ecc' : __ecc, + 'sqrta' : __sqrta, + 'omega0' : __omega0, + 'omegadot' : __omegadot, + 'w' : __w, + 'inc' : __inc, + 'inc_dot' : __inc_dot, + 'af0' : __af0, + 'af1' : __af1, + 'af2' : __af2, + 'toc' : __toc, + 'iode' : __iode, + 'iodc' : __iodc, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.common = res['common'] + self.bgd_e1e5a = res['bgd_e1e5a'] + self.bgd_e1e5b = res['bgd_e1e5b'] + self.c_rs = res['c_rs'] + self.c_rc = res['c_rc'] + self.c_uc = res['c_uc'] + self.c_us = res['c_us'] + self.c_ic = res['c_ic'] + self.c_is = res['c_is'] + self.dn = res['dn'] + self.m0 = res['m0'] + self.ecc = res['ecc'] + self.sqrta = res['sqrta'] + self.omega0 = res['omega0'] + self.omegadot = res['omegadot'] + self.w = res['w'] + self.inc = res['inc'] + self.inc_dot = res['inc_dot'] + self.af0 = res['af0'] + self.af1 = res['af1'] + self.af2 = res['af2'] + self.toc = res['toc'] + self.iode = res['iode'] + self.iodc = res['iodc'] + return res, off, length + +SBP_MSG_EPHEMERIS_SBAS_DEP_A = 0x0082 +class MsgEphemerisSbasDepA(SBP): + """SBP class for message MSG_EPHEMERIS_SBAS_DEP_A (0x0082). + + You can have MSG_EPHEMERIS_SBAS_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + """ + __slots__ = ['common', + 'pos', + 'vel', + 'acc', + 'a_gf0', + 'a_gf1', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__common, offset, length) = offset, EphemerisCommonContentDepA.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pos, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__vel, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__acc, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__a_gf0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__a_gf1, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'common' : __common, + 'pos' : __pos, + 'vel' : __vel, + 'acc' : __acc, + 'a_gf0' : __a_gf0, + 'a_gf1' : __a_gf1, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.common = res['common'] + self.pos = res['pos'] + self.vel = res['vel'] + self.acc = res['acc'] + self.a_gf0 = res['a_gf0'] + self.a_gf1 = res['a_gf1'] + return res, off, length + +SBP_MSG_EPHEMERIS_GLO_DEP_A = 0x0083 +class MsgEphemerisGloDepA(SBP): + """SBP class for message MSG_EPHEMERIS_GLO_DEP_A (0x0083). + + You can have MSG_EPHEMERIS_GLO_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The ephemeris message returns a set of satellite orbit +parameters that is used to calculate GLO satellite position, +velocity, and clock offset. Please see the GLO ICD 5.1 "Table 4.5 +Characteristics of words of immediate information (ephemeris parameters)" +for more details. + + + """ + __slots__ = ['common', + 'gamma', + 'tau', + 'pos', + 'vel', + 'acc', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__common, offset, length) = offset, EphemerisCommonContentDepA.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__gamma, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tau, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pos, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__vel, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__acc, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'common' : __common, + 'gamma' : __gamma, + 'tau' : __tau, + 'pos' : __pos, + 'vel' : __vel, + 'acc' : __acc, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.common = res['common'] + self.gamma = res['gamma'] + self.tau = res['tau'] + self.pos = res['pos'] + self.vel = res['vel'] + self.acc = res['acc'] + return res, off, length + +SBP_MSG_EPHEMERIS_SBAS_DEP_B = 0x0084 +class MsgEphemerisSbasDepB(SBP): + """SBP class for message MSG_EPHEMERIS_SBAS_DEP_B (0x0084). + + You can have MSG_EPHEMERIS_SBAS_DEP_B inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This observation message has been deprecated in favor of +ephemeris message using floats for size reduction. + + + """ + __slots__ = ['common', + 'pos', + 'vel', + 'acc', + 'a_gf0', + 'a_gf1', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__common, offset, length) = offset, EphemerisCommonContentDepB.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pos, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__vel, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__acc, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__a_gf0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__a_gf1, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'common' : __common, + 'pos' : __pos, + 'vel' : __vel, + 'acc' : __acc, + 'a_gf0' : __a_gf0, + 'a_gf1' : __a_gf1, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.common = res['common'] + self.pos = res['pos'] + self.vel = res['vel'] + self.acc = res['acc'] + self.a_gf0 = res['a_gf0'] + self.a_gf1 = res['a_gf1'] + return res, off, length + +SBP_MSG_EPHEMERIS_SBAS = 0x008C +class MsgEphemerisSbas(SBP): + """SBP class for message MSG_EPHEMERIS_SBAS (0x008C). + + You can have MSG_EPHEMERIS_SBAS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + """ + __slots__ = ['common', + 'pos', + 'vel', + 'acc', + 'a_gf0', + 'a_gf1', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__common, offset, length) = offset, EphemerisCommonContent.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pos, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__vel, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__acc, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__a_gf0, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__a_gf1, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'common' : __common, + 'pos' : __pos, + 'vel' : __vel, + 'acc' : __acc, + 'a_gf0' : __a_gf0, + 'a_gf1' : __a_gf1, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.common = res['common'] + self.pos = res['pos'] + self.vel = res['vel'] + self.acc = res['acc'] + self.a_gf0 = res['a_gf0'] + self.a_gf1 = res['a_gf1'] + return res, off, length + +SBP_MSG_EPHEMERIS_GLO_DEP_B = 0x0085 +class MsgEphemerisGloDepB(SBP): + """SBP class for message MSG_EPHEMERIS_GLO_DEP_B (0x0085). + + You can have MSG_EPHEMERIS_GLO_DEP_B inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The ephemeris message returns a set of satellite orbit +parameters that is used to calculate GLO satellite position, +velocity, and clock offset. Please see the GLO ICD 5.1 "Table 4.5 +Characteristics of words of immediate information (ephemeris parameters)" +for more details. + + + """ + __slots__ = ['common', + 'gamma', + 'tau', + 'pos', + 'vel', + 'acc', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__common, offset, length) = offset, EphemerisCommonContentDepB.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__gamma, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tau, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pos, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__vel, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__acc, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'common' : __common, + 'gamma' : __gamma, + 'tau' : __tau, + 'pos' : __pos, + 'vel' : __vel, + 'acc' : __acc, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.common = res['common'] + self.gamma = res['gamma'] + self.tau = res['tau'] + self.pos = res['pos'] + self.vel = res['vel'] + self.acc = res['acc'] + return res, off, length + +SBP_MSG_EPHEMERIS_GLO_DEP_C = 0x0087 +class MsgEphemerisGloDepC(SBP): + """SBP class for message MSG_EPHEMERIS_GLO_DEP_C (0x0087). + + You can have MSG_EPHEMERIS_GLO_DEP_C inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The ephemeris message returns a set of satellite orbit +parameters that is used to calculate GLO satellite position, +velocity, and clock offset. Please see the GLO ICD 5.1 "Table 4.5 +Characteristics of words of immediate information (ephemeris parameters)" +for more details. + + + """ + __slots__ = ['common', + 'gamma', + 'tau', + 'd_tau', + 'pos', + 'vel', + 'acc', + 'fcn', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__common, offset, length) = offset, EphemerisCommonContentDepB.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__gamma, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tau, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__d_tau, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pos, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__vel, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__acc, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__fcn, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'common' : __common, + 'gamma' : __gamma, + 'tau' : __tau, + 'd_tau' : __d_tau, + 'pos' : __pos, + 'vel' : __vel, + 'acc' : __acc, + 'fcn' : __fcn, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.common = res['common'] + self.gamma = res['gamma'] + self.tau = res['tau'] + self.d_tau = res['d_tau'] + self.pos = res['pos'] + self.vel = res['vel'] + self.acc = res['acc'] + self.fcn = res['fcn'] + return res, off, length + +SBP_MSG_EPHEMERIS_GLO_DEP_D = 0x0088 +class MsgEphemerisGloDepD(SBP): + """SBP class for message MSG_EPHEMERIS_GLO_DEP_D (0x0088). + + You can have MSG_EPHEMERIS_GLO_DEP_D inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This observation message has been deprecated in favor of +ephemeris message using floats for size reduction. + + + """ + __slots__ = ['common', + 'gamma', + 'tau', + 'd_tau', + 'pos', + 'vel', + 'acc', + 'fcn', + 'iod', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__common, offset, length) = offset, EphemerisCommonContentDepB.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__gamma, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tau, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__d_tau, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pos, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__vel, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__acc, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__fcn, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iod, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'common' : __common, + 'gamma' : __gamma, + 'tau' : __tau, + 'd_tau' : __d_tau, + 'pos' : __pos, + 'vel' : __vel, + 'acc' : __acc, + 'fcn' : __fcn, + 'iod' : __iod, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.common = res['common'] + self.gamma = res['gamma'] + self.tau = res['tau'] + self.d_tau = res['d_tau'] + self.pos = res['pos'] + self.vel = res['vel'] + self.acc = res['acc'] + self.fcn = res['fcn'] + self.iod = res['iod'] + return res, off, length + +SBP_MSG_EPHEMERIS_GLO = 0x008B +class MsgEphemerisGlo(SBP): + """SBP class for message MSG_EPHEMERIS_GLO (0x008B). + + You can have MSG_EPHEMERIS_GLO inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The ephemeris message returns a set of satellite orbit +parameters that is used to calculate GLO satellite position, +velocity, and clock offset. Please see the GLO ICD 5.1 "Table 4.5 +Characteristics of words of immediate information (ephemeris parameters)" +for more details. + + + """ + __slots__ = ['common', + 'gamma', + 'tau', + 'd_tau', + 'pos', + 'vel', + 'acc', + 'fcn', + 'iod', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__common, offset, length) = offset, EphemerisCommonContent.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__gamma, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tau, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__d_tau, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pos, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__vel, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__acc, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__fcn, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iod, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'common' : __common, + 'gamma' : __gamma, + 'tau' : __tau, + 'd_tau' : __d_tau, + 'pos' : __pos, + 'vel' : __vel, + 'acc' : __acc, + 'fcn' : __fcn, + 'iod' : __iod, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.common = res['common'] + self.gamma = res['gamma'] + self.tau = res['tau'] + self.d_tau = res['d_tau'] + self.pos = res['pos'] + self.vel = res['vel'] + self.acc = res['acc'] + self.fcn = res['fcn'] + self.iod = res['iod'] + return res, off, length + +SBP_MSG_EPHEMERIS_DEP_D = 0x0080 +class MsgEphemerisDepD(SBP): + """SBP class for message MSG_EPHEMERIS_DEP_D (0x0080). + + You can have MSG_EPHEMERIS_DEP_D inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The ephemeris message returns a set of satellite orbit +parameters that is used to calculate GPS satellite position, +velocity, and clock offset. Please see the Navstar GPS +Space Segment/Navigation user interfaces (ICD-GPS-200, Table +20-III) for more details. + + + """ + __slots__ = ['tgd', + 'c_rs', + 'c_rc', + 'c_uc', + 'c_us', + 'c_ic', + 'c_is', + 'dn', + 'm0', + 'ecc', + 'sqrta', + 'omega0', + 'omegadot', + 'w', + 'inc', + 'inc_dot', + 'af0', + 'af1', + 'af2', + 'toe_tow', + 'toe_wn', + 'toc_tow', + 'toc_wn', + 'valid', + 'healthy', + 'sid', + 'iode', + 'iodc', + 'reserved', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tgd, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rs, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_uc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_us, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_ic, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_is, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af2, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toe_tow, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toe_wn, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toc_tow, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toc_wn, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__healthy, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iode, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iodc, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__reserved, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tgd' : __tgd, + 'c_rs' : __c_rs, + 'c_rc' : __c_rc, + 'c_uc' : __c_uc, + 'c_us' : __c_us, + 'c_ic' : __c_ic, + 'c_is' : __c_is, + 'dn' : __dn, + 'm0' : __m0, + 'ecc' : __ecc, + 'sqrta' : __sqrta, + 'omega0' : __omega0, + 'omegadot' : __omegadot, + 'w' : __w, + 'inc' : __inc, + 'inc_dot' : __inc_dot, + 'af0' : __af0, + 'af1' : __af1, + 'af2' : __af2, + 'toe_tow' : __toe_tow, + 'toe_wn' : __toe_wn, + 'toc_tow' : __toc_tow, + 'toc_wn' : __toc_wn, + 'valid' : __valid, + 'healthy' : __healthy, + 'sid' : __sid, + 'iode' : __iode, + 'iodc' : __iodc, + 'reserved' : __reserved, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tgd = res['tgd'] + self.c_rs = res['c_rs'] + self.c_rc = res['c_rc'] + self.c_uc = res['c_uc'] + self.c_us = res['c_us'] + self.c_ic = res['c_ic'] + self.c_is = res['c_is'] + self.dn = res['dn'] + self.m0 = res['m0'] + self.ecc = res['ecc'] + self.sqrta = res['sqrta'] + self.omega0 = res['omega0'] + self.omegadot = res['omegadot'] + self.w = res['w'] + self.inc = res['inc'] + self.inc_dot = res['inc_dot'] + self.af0 = res['af0'] + self.af1 = res['af1'] + self.af2 = res['af2'] + self.toe_tow = res['toe_tow'] + self.toe_wn = res['toe_wn'] + self.toc_tow = res['toc_tow'] + self.toc_wn = res['toc_wn'] + self.valid = res['valid'] + self.healthy = res['healthy'] + self.sid = res['sid'] + self.iode = res['iode'] + self.iodc = res['iodc'] + self.reserved = res['reserved'] + return res, off, length + +SBP_MSG_EPHEMERIS_DEP_A = 0x001A +class MsgEphemerisDepA(SBP): + """SBP class for message MSG_EPHEMERIS_DEP_A (0x001A). + + You can have MSG_EPHEMERIS_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['tgd', + 'c_rs', + 'c_rc', + 'c_uc', + 'c_us', + 'c_ic', + 'c_is', + 'dn', + 'm0', + 'ecc', + 'sqrta', + 'omega0', + 'omegadot', + 'w', + 'inc', + 'inc_dot', + 'af0', + 'af1', + 'af2', + 'toe_tow', + 'toe_wn', + 'toc_tow', + 'toc_wn', + 'valid', + 'healthy', + 'prn', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tgd, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rs, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_uc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_us, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_ic, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_is, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af2, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toe_tow, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toe_wn, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toc_tow, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toc_wn, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__healthy, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__prn, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tgd' : __tgd, + 'c_rs' : __c_rs, + 'c_rc' : __c_rc, + 'c_uc' : __c_uc, + 'c_us' : __c_us, + 'c_ic' : __c_ic, + 'c_is' : __c_is, + 'dn' : __dn, + 'm0' : __m0, + 'ecc' : __ecc, + 'sqrta' : __sqrta, + 'omega0' : __omega0, + 'omegadot' : __omegadot, + 'w' : __w, + 'inc' : __inc, + 'inc_dot' : __inc_dot, + 'af0' : __af0, + 'af1' : __af1, + 'af2' : __af2, + 'toe_tow' : __toe_tow, + 'toe_wn' : __toe_wn, + 'toc_tow' : __toc_tow, + 'toc_wn' : __toc_wn, + 'valid' : __valid, + 'healthy' : __healthy, + 'prn' : __prn, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tgd = res['tgd'] + self.c_rs = res['c_rs'] + self.c_rc = res['c_rc'] + self.c_uc = res['c_uc'] + self.c_us = res['c_us'] + self.c_ic = res['c_ic'] + self.c_is = res['c_is'] + self.dn = res['dn'] + self.m0 = res['m0'] + self.ecc = res['ecc'] + self.sqrta = res['sqrta'] + self.omega0 = res['omega0'] + self.omegadot = res['omegadot'] + self.w = res['w'] + self.inc = res['inc'] + self.inc_dot = res['inc_dot'] + self.af0 = res['af0'] + self.af1 = res['af1'] + self.af2 = res['af2'] + self.toe_tow = res['toe_tow'] + self.toe_wn = res['toe_wn'] + self.toc_tow = res['toc_tow'] + self.toc_wn = res['toc_wn'] + self.valid = res['valid'] + self.healthy = res['healthy'] + self.prn = res['prn'] + return res, off, length + +SBP_MSG_EPHEMERIS_DEP_B = 0x0046 +class MsgEphemerisDepB(SBP): + """SBP class for message MSG_EPHEMERIS_DEP_B (0x0046). + + You can have MSG_EPHEMERIS_DEP_B inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['tgd', + 'c_rs', + 'c_rc', + 'c_uc', + 'c_us', + 'c_ic', + 'c_is', + 'dn', + 'm0', + 'ecc', + 'sqrta', + 'omega0', + 'omegadot', + 'w', + 'inc', + 'inc_dot', + 'af0', + 'af1', + 'af2', + 'toe_tow', + 'toe_wn', + 'toc_tow', + 'toc_wn', + 'valid', + 'healthy', + 'prn', + 'iode', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tgd, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rs, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_uc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_us, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_ic, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_is, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af2, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toe_tow, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toe_wn, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toc_tow, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toc_wn, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__healthy, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__prn, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iode, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tgd' : __tgd, + 'c_rs' : __c_rs, + 'c_rc' : __c_rc, + 'c_uc' : __c_uc, + 'c_us' : __c_us, + 'c_ic' : __c_ic, + 'c_is' : __c_is, + 'dn' : __dn, + 'm0' : __m0, + 'ecc' : __ecc, + 'sqrta' : __sqrta, + 'omega0' : __omega0, + 'omegadot' : __omegadot, + 'w' : __w, + 'inc' : __inc, + 'inc_dot' : __inc_dot, + 'af0' : __af0, + 'af1' : __af1, + 'af2' : __af2, + 'toe_tow' : __toe_tow, + 'toe_wn' : __toe_wn, + 'toc_tow' : __toc_tow, + 'toc_wn' : __toc_wn, + 'valid' : __valid, + 'healthy' : __healthy, + 'prn' : __prn, + 'iode' : __iode, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tgd = res['tgd'] + self.c_rs = res['c_rs'] + self.c_rc = res['c_rc'] + self.c_uc = res['c_uc'] + self.c_us = res['c_us'] + self.c_ic = res['c_ic'] + self.c_is = res['c_is'] + self.dn = res['dn'] + self.m0 = res['m0'] + self.ecc = res['ecc'] + self.sqrta = res['sqrta'] + self.omega0 = res['omega0'] + self.omegadot = res['omegadot'] + self.w = res['w'] + self.inc = res['inc'] + self.inc_dot = res['inc_dot'] + self.af0 = res['af0'] + self.af1 = res['af1'] + self.af2 = res['af2'] + self.toe_tow = res['toe_tow'] + self.toe_wn = res['toe_wn'] + self.toc_tow = res['toc_tow'] + self.toc_wn = res['toc_wn'] + self.valid = res['valid'] + self.healthy = res['healthy'] + self.prn = res['prn'] + self.iode = res['iode'] + return res, off, length + +SBP_MSG_EPHEMERIS_DEP_C = 0x0047 +class MsgEphemerisDepC(SBP): + """SBP class for message MSG_EPHEMERIS_DEP_C (0x0047). + + You can have MSG_EPHEMERIS_DEP_C inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The ephemeris message returns a set of satellite orbit +parameters that is used to calculate GPS satellite position, +velocity, and clock offset. Please see the Navstar GPS +Space Segment/Navigation user interfaces (ICD-GPS-200, Table +20-III) for more details. + + + """ + __slots__ = ['tgd', + 'c_rs', + 'c_rc', + 'c_uc', + 'c_us', + 'c_ic', + 'c_is', + 'dn', + 'm0', + 'ecc', + 'sqrta', + 'omega0', + 'omegadot', + 'w', + 'inc', + 'inc_dot', + 'af0', + 'af1', + 'af2', + 'toe_tow', + 'toe_wn', + 'toc_tow', + 'toc_wn', + 'valid', + 'healthy', + 'sid', + 'iode', + 'iodc', + 'reserved', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tgd, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rs, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_rc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_uc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_us, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_ic, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c_is, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af2, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toe_tow, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toe_wn, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toc_tow, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toc_wn, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__healthy, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iode, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iodc, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__reserved, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tgd' : __tgd, + 'c_rs' : __c_rs, + 'c_rc' : __c_rc, + 'c_uc' : __c_uc, + 'c_us' : __c_us, + 'c_ic' : __c_ic, + 'c_is' : __c_is, + 'dn' : __dn, + 'm0' : __m0, + 'ecc' : __ecc, + 'sqrta' : __sqrta, + 'omega0' : __omega0, + 'omegadot' : __omegadot, + 'w' : __w, + 'inc' : __inc, + 'inc_dot' : __inc_dot, + 'af0' : __af0, + 'af1' : __af1, + 'af2' : __af2, + 'toe_tow' : __toe_tow, + 'toe_wn' : __toe_wn, + 'toc_tow' : __toc_tow, + 'toc_wn' : __toc_wn, + 'valid' : __valid, + 'healthy' : __healthy, + 'sid' : __sid, + 'iode' : __iode, + 'iodc' : __iodc, + 'reserved' : __reserved, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tgd = res['tgd'] + self.c_rs = res['c_rs'] + self.c_rc = res['c_rc'] + self.c_uc = res['c_uc'] + self.c_us = res['c_us'] + self.c_ic = res['c_ic'] + self.c_is = res['c_is'] + self.dn = res['dn'] + self.m0 = res['m0'] + self.ecc = res['ecc'] + self.sqrta = res['sqrta'] + self.omega0 = res['omega0'] + self.omegadot = res['omegadot'] + self.w = res['w'] + self.inc = res['inc'] + self.inc_dot = res['inc_dot'] + self.af0 = res['af0'] + self.af1 = res['af1'] + self.af2 = res['af2'] + self.toe_tow = res['toe_tow'] + self.toe_wn = res['toe_wn'] + self.toc_tow = res['toc_tow'] + self.toc_wn = res['toc_wn'] + self.valid = res['valid'] + self.healthy = res['healthy'] + self.sid = res['sid'] + self.iode = res['iode'] + self.iodc = res['iodc'] + self.reserved = res['reserved'] + return res, off, length + +class ObservationHeaderDep(object): + """SBP class for message ObservationHeaderDep + + You can have ObservationHeaderDep inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Header of a GPS observation message. + + """ + __slots__ = ['t', + 'n_obs', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__t, offset, length) = offset, GPSTimeDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_obs, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 't' : __t, + 'n_obs' : __n_obs, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.t = res['t'] + self.n_obs = res['n_obs'] + return res, off, length + +class CarrierPhaseDepA(object): + """SBP class for message CarrierPhaseDepA + + You can have CarrierPhaseDepA inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Carrier phase measurement in cycles represented as a 40-bit +fixed point number with Q32.8 layout, i.e. 32-bits of whole +cycles and 8-bits of fractional cycles. This has the opposite +sign convention than a typical GPS receiver and the phase has +the opposite sign as the pseudorange. + + + """ + __slots__ = ['i', + 'f', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__i, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__f, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'i' : __i, + 'f' : __f, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.i = res['i'] + self.f = res['f'] + return res, off, length + +class PackedObsContentDepA(object): + """SBP class for message PackedObsContentDepA + + You can have PackedObsContentDepA inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['P', + 'L', + 'cn0', + 'lock', + 'prn', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__P, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__L, offset, length) = offset, CarrierPhaseDepA.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cn0, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__lock, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__prn, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'P' : __P, + 'L' : __L, + 'cn0' : __cn0, + 'lock' : __lock, + 'prn' : __prn, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.P = res['P'] + self.L = res['L'] + self.cn0 = res['cn0'] + self.lock = res['lock'] + self.prn = res['prn'] + return res, off, length + +class PackedObsContentDepB(object): + """SBP class for message PackedObsContentDepB + + You can have PackedObsContentDepB inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Pseudorange and carrier phase observation for a satellite being +tracked. Pseudoranges are referenced to a nominal pseudorange. + + + """ + __slots__ = ['P', + 'L', + 'cn0', + 'lock', + 'sid', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__P, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__L, offset, length) = offset, CarrierPhaseDepA.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cn0, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__lock, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'P' : __P, + 'L' : __L, + 'cn0' : __cn0, + 'lock' : __lock, + 'sid' : __sid, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.P = res['P'] + self.L = res['L'] + self.cn0 = res['cn0'] + self.lock = res['lock'] + self.sid = res['sid'] + return res, off, length + +class PackedObsContentDepC(object): + """SBP class for message PackedObsContentDepC + + You can have PackedObsContentDepC inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Pseudorange and carrier phase observation for a satellite being +tracked. The observations are be interoperable with 3rd party +receivers and conform with typical RTCMv3 GNSS observations. + + + """ + __slots__ = ['P', + 'L', + 'cn0', + 'lock', + 'sid', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__P, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__L, offset, length) = offset, CarrierPhase.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cn0, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__lock, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'P' : __P, + 'L' : __L, + 'cn0' : __cn0, + 'lock' : __lock, + 'sid' : __sid, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.P = res['P'] + self.L = res['L'] + self.cn0 = res['cn0'] + self.lock = res['lock'] + self.sid = res['sid'] + return res, off, length + +SBP_MSG_OBS_DEP_A = 0x0045 +class MsgObsDepA(SBP): + """SBP class for message MSG_OBS_DEP_A (0x0045). + + You can have MSG_OBS_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['header', + 'obs', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__header, offset, length) = offset, ObservationHeaderDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__obs, offset, length) = offset, get_array(PackedObsContentDepA.parse_members)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'header' : __header, + 'obs' : __obs, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.header = res['header'] + self.obs = res['obs'] + return res, off, length + +SBP_MSG_OBS_DEP_B = 0x0043 +class MsgObsDepB(SBP): + """SBP class for message MSG_OBS_DEP_B (0x0043). + + You can have MSG_OBS_DEP_B inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This observation message has been deprecated in favor of +observations that are more interoperable. This message +should be used for observations referenced to +a nominal pseudorange which are not interoperable with +most 3rd party GNSS receievers or typical RTCMv3 +observations. + + + """ + __slots__ = ['header', + 'obs', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__header, offset, length) = offset, ObservationHeaderDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__obs, offset, length) = offset, get_array(PackedObsContentDepB.parse_members)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'header' : __header, + 'obs' : __obs, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.header = res['header'] + self.obs = res['obs'] + return res, off, length + +SBP_MSG_OBS_DEP_C = 0x0049 +class MsgObsDepC(SBP): + """SBP class for message MSG_OBS_DEP_C (0x0049). + + You can have MSG_OBS_DEP_C inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The GPS observations message reports all the raw pseudorange and +carrier phase observations for the satellites being tracked by +the device. Carrier phase observation here is represented as a +40-bit fixed point number with Q32.8 layout (i.e. 32-bits of +whole cycles and 8-bits of fractional cycles). The observations +are interoperable with 3rd party receivers and conform +with typical RTCMv3 GNSS observations. + + + """ + __slots__ = ['header', + 'obs', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__header, offset, length) = offset, ObservationHeaderDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__obs, offset, length) = offset, get_array(PackedObsContentDepC.parse_members)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'header' : __header, + 'obs' : __obs, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.header = res['header'] + self.obs = res['obs'] + return res, off, length + +SBP_MSG_IONO = 0x0090 +class MsgIono(SBP): + """SBP class for message MSG_IONO (0x0090). + + You can have MSG_IONO inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The ionospheric parameters which allow the "L1 only" or "L2 only" user to +utilize the ionospheric model for computation of the ionospheric delay. +Please see ICD-GPS-200 (Chapter 20.3.3.5.1.7) for more details. + + + """ + __slots__ = ['t_nmct', + 'a0', + 'a1', + 'a2', + 'a3', + 'b0', + 'b1', + 'b2', + 'b3', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__t_nmct, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__a0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__a1, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__a2, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__a3, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__b0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__b1, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__b2, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__b3, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 't_nmct' : __t_nmct, + 'a0' : __a0, + 'a1' : __a1, + 'a2' : __a2, + 'a3' : __a3, + 'b0' : __b0, + 'b1' : __b1, + 'b2' : __b2, + 'b3' : __b3, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.t_nmct = res['t_nmct'] + self.a0 = res['a0'] + self.a1 = res['a1'] + self.a2 = res['a2'] + self.a3 = res['a3'] + self.b0 = res['b0'] + self.b1 = res['b1'] + self.b2 = res['b2'] + self.b3 = res['b3'] + return res, off, length + +SBP_MSG_SV_CONFIGURATION_GPS_DEP = 0x0091 +class MsgSvConfigurationGPSDep(SBP): + """SBP class for message MSG_SV_CONFIGURATION_GPS_DEP (0x0091). + + You can have MSG_SV_CONFIGURATION_GPS_DEP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Please see ICD-GPS-200 (Chapter 20.3.3.5.1.4) for more details. + + + """ + __slots__ = ['t_nmct', + 'l2c_mask', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__t_nmct, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__l2c_mask, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 't_nmct' : __t_nmct, + 'l2c_mask' : __l2c_mask, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.t_nmct = res['t_nmct'] + self.l2c_mask = res['l2c_mask'] + return res, off, length + +class GnssCapb(object): + """SBP class for message GnssCapb + + You can have GnssCapb inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + """ + __slots__ = ['gps_active', + 'gps_l2c', + 'gps_l5', + 'glo_active', + 'glo_l2of', + 'glo_l3', + 'sbas_active', + 'sbas_l5', + 'bds_active', + 'bds_d2nav', + 'bds_b2', + 'bds_b2a', + 'qzss_active', + 'gal_active', + 'gal_e5', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__gps_active, offset, length) = offset, get_u64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__gps_l2c, offset, length) = offset, get_u64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__gps_l5, offset, length) = offset, get_u64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__glo_active, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__glo_l2of, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__glo_l3, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sbas_active, offset, length) = offset, get_u64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sbas_l5, offset, length) = offset, get_u64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__bds_active, offset, length) = offset, get_u64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__bds_d2nav, offset, length) = offset, get_u64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__bds_b2, offset, length) = offset, get_u64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__bds_b2a, offset, length) = offset, get_u64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__qzss_active, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__gal_active, offset, length) = offset, get_u64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__gal_e5, offset, length) = offset, get_u64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'gps_active' : __gps_active, + 'gps_l2c' : __gps_l2c, + 'gps_l5' : __gps_l5, + 'glo_active' : __glo_active, + 'glo_l2of' : __glo_l2of, + 'glo_l3' : __glo_l3, + 'sbas_active' : __sbas_active, + 'sbas_l5' : __sbas_l5, + 'bds_active' : __bds_active, + 'bds_d2nav' : __bds_d2nav, + 'bds_b2' : __bds_b2, + 'bds_b2a' : __bds_b2a, + 'qzss_active' : __qzss_active, + 'gal_active' : __gal_active, + 'gal_e5' : __gal_e5, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.gps_active = res['gps_active'] + self.gps_l2c = res['gps_l2c'] + self.gps_l5 = res['gps_l5'] + self.glo_active = res['glo_active'] + self.glo_l2of = res['glo_l2of'] + self.glo_l3 = res['glo_l3'] + self.sbas_active = res['sbas_active'] + self.sbas_l5 = res['sbas_l5'] + self.bds_active = res['bds_active'] + self.bds_d2nav = res['bds_d2nav'] + self.bds_b2 = res['bds_b2'] + self.bds_b2a = res['bds_b2a'] + self.qzss_active = res['qzss_active'] + self.gal_active = res['gal_active'] + self.gal_e5 = res['gal_e5'] + return res, off, length + +SBP_MSG_GNSS_CAPB = 0x0096 +class MsgGnssCapb(SBP): + """SBP class for message MSG_GNSS_CAPB (0x0096). + + You can have MSG_GNSS_CAPB inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + """ + __slots__ = ['t_nmct', + 'gc', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__t_nmct, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__gc, offset, length) = offset, GnssCapb.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 't_nmct' : __t_nmct, + 'gc' : __gc, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.t_nmct = res['t_nmct'] + self.gc = res['gc'] + return res, off, length + +SBP_MSG_GROUP_DELAY_DEP_A = 0x0092 +class MsgGroupDelayDepA(SBP): + """SBP class for message MSG_GROUP_DELAY_DEP_A (0x0092). + + You can have MSG_GROUP_DELAY_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Please see ICD-GPS-200 (30.3.3.3.1.1) for more details. + + """ + __slots__ = ['t_op', + 'prn', + 'valid', + 'tgd', + 'isc_l1ca', + 'isc_l2c', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__t_op, offset, length) = offset, GPSTimeDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__prn, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tgd, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__isc_l1ca, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__isc_l2c, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 't_op' : __t_op, + 'prn' : __prn, + 'valid' : __valid, + 'tgd' : __tgd, + 'isc_l1ca' : __isc_l1ca, + 'isc_l2c' : __isc_l2c, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.t_op = res['t_op'] + self.prn = res['prn'] + self.valid = res['valid'] + self.tgd = res['tgd'] + self.isc_l1ca = res['isc_l1ca'] + self.isc_l2c = res['isc_l2c'] + return res, off, length + +SBP_MSG_GROUP_DELAY_DEP_B = 0x0093 +class MsgGroupDelayDepB(SBP): + """SBP class for message MSG_GROUP_DELAY_DEP_B (0x0093). + + You can have MSG_GROUP_DELAY_DEP_B inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Please see ICD-GPS-200 (30.3.3.3.1.1) for more details. + + """ + __slots__ = ['t_op', + 'sid', + 'valid', + 'tgd', + 'isc_l1ca', + 'isc_l2c', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__t_op, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tgd, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__isc_l1ca, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__isc_l2c, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 't_op' : __t_op, + 'sid' : __sid, + 'valid' : __valid, + 'tgd' : __tgd, + 'isc_l1ca' : __isc_l1ca, + 'isc_l2c' : __isc_l2c, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.t_op = res['t_op'] + self.sid = res['sid'] + self.valid = res['valid'] + self.tgd = res['tgd'] + self.isc_l1ca = res['isc_l1ca'] + self.isc_l2c = res['isc_l2c'] + return res, off, length + +SBP_MSG_GROUP_DELAY = 0x0094 +class MsgGroupDelay(SBP): + """SBP class for message MSG_GROUP_DELAY (0x0094). + + You can have MSG_GROUP_DELAY inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Please see ICD-GPS-200 (30.3.3.3.1.1) for more details. + + """ + __slots__ = ['t_op', + 'sid', + 'valid', + 'tgd', + 'isc_l1ca', + 'isc_l2c', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__t_op, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tgd, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__isc_l1ca, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__isc_l2c, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 't_op' : __t_op, + 'sid' : __sid, + 'valid' : __valid, + 'tgd' : __tgd, + 'isc_l1ca' : __isc_l1ca, + 'isc_l2c' : __isc_l2c, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.t_op = res['t_op'] + self.sid = res['sid'] + self.valid = res['valid'] + self.tgd = res['tgd'] + self.isc_l1ca = res['isc_l1ca'] + self.isc_l2c = res['isc_l2c'] + return res, off, length + +class AlmanacCommonContent(object): + """SBP class for message AlmanacCommonContent + + You can have AlmanacCommonContent inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + """ + __slots__ = ['sid', + 'toa', + 'ura', + 'fit_interval', + 'valid', + 'health_bits', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toa, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ura, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__fit_interval, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__health_bits, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sid' : __sid, + 'toa' : __toa, + 'ura' : __ura, + 'fit_interval' : __fit_interval, + 'valid' : __valid, + 'health_bits' : __health_bits, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sid = res['sid'] + self.toa = res['toa'] + self.ura = res['ura'] + self.fit_interval = res['fit_interval'] + self.valid = res['valid'] + self.health_bits = res['health_bits'] + return res, off, length + +class AlmanacCommonContentDep(object): + """SBP class for message AlmanacCommonContentDep + + You can have AlmanacCommonContentDep inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + + """ + __slots__ = ['sid', + 'toa', + 'ura', + 'fit_interval', + 'valid', + 'health_bits', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__toa, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ura, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__fit_interval, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__health_bits, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sid' : __sid, + 'toa' : __toa, + 'ura' : __ura, + 'fit_interval' : __fit_interval, + 'valid' : __valid, + 'health_bits' : __health_bits, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sid = res['sid'] + self.toa = res['toa'] + self.ura = res['ura'] + self.fit_interval = res['fit_interval'] + self.valid = res['valid'] + self.health_bits = res['health_bits'] + return res, off, length + +SBP_MSG_ALMANAC_GPS_DEP = 0x0070 +class MsgAlmanacGPSDep(SBP): + """SBP class for message MSG_ALMANAC_GPS_DEP (0x0070). + + You can have MSG_ALMANAC_GPS_DEP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The almanac message returns a set of satellite orbit parameters. Almanac +data is not very precise and is considered valid for up to several months. +Please see the Navstar GPS Space Segment/Navigation user interfaces +(ICD-GPS-200, Chapter 20.3.3.5.1.2 Almanac Data) for more details. + + + """ + __slots__ = ['common', + 'm0', + 'ecc', + 'sqrta', + 'omega0', + 'omegadot', + 'w', + 'inc', + 'af0', + 'af1', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__common, offset, length) = offset, AlmanacCommonContentDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'common' : __common, + 'm0' : __m0, + 'ecc' : __ecc, + 'sqrta' : __sqrta, + 'omega0' : __omega0, + 'omegadot' : __omegadot, + 'w' : __w, + 'inc' : __inc, + 'af0' : __af0, + 'af1' : __af1, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.common = res['common'] + self.m0 = res['m0'] + self.ecc = res['ecc'] + self.sqrta = res['sqrta'] + self.omega0 = res['omega0'] + self.omegadot = res['omegadot'] + self.w = res['w'] + self.inc = res['inc'] + self.af0 = res['af0'] + self.af1 = res['af1'] + return res, off, length + +SBP_MSG_ALMANAC_GPS = 0x0072 +class MsgAlmanacGPS(SBP): + """SBP class for message MSG_ALMANAC_GPS (0x0072). + + You can have MSG_ALMANAC_GPS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The almanac message returns a set of satellite orbit parameters. Almanac +data is not very precise and is considered valid for up to several months. +Please see the Navstar GPS Space Segment/Navigation user interfaces +(ICD-GPS-200, Chapter 20.3.3.5.1.2 Almanac Data) for more details. + + + """ + __slots__ = ['common', + 'm0', + 'ecc', + 'sqrta', + 'omega0', + 'omegadot', + 'w', + 'inc', + 'af0', + 'af1', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__common, offset, length) = offset, AlmanacCommonContent.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'common' : __common, + 'm0' : __m0, + 'ecc' : __ecc, + 'sqrta' : __sqrta, + 'omega0' : __omega0, + 'omegadot' : __omegadot, + 'w' : __w, + 'inc' : __inc, + 'af0' : __af0, + 'af1' : __af1, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.common = res['common'] + self.m0 = res['m0'] + self.ecc = res['ecc'] + self.sqrta = res['sqrta'] + self.omega0 = res['omega0'] + self.omegadot = res['omegadot'] + self.w = res['w'] + self.inc = res['inc'] + self.af0 = res['af0'] + self.af1 = res['af1'] + return res, off, length + +SBP_MSG_ALMANAC_GLO_DEP = 0x0071 +class MsgAlmanacGloDep(SBP): + """SBP class for message MSG_ALMANAC_GLO_DEP (0x0071). + + You can have MSG_ALMANAC_GLO_DEP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The almanac message returns a set of satellite orbit parameters. Almanac +data is not very precise and is considered valid for up to several months. +Please see the GLO ICD 5.1 "Chapter 4.5 Non-immediate information and +almanac" for details. + + + """ + __slots__ = ['common', + 'lambda_na', + 't_lambda_na', + 'i', + 't', + 't_dot', + 'epsilon', + 'omega', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__common, offset, length) = offset, AlmanacCommonContentDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__lambda_na, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__t_lambda_na, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__i, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__t, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__t_dot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__epsilon, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omega, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'common' : __common, + 'lambda_na' : __lambda_na, + 't_lambda_na' : __t_lambda_na, + 'i' : __i, + 't' : __t, + 't_dot' : __t_dot, + 'epsilon' : __epsilon, + 'omega' : __omega, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.common = res['common'] + self.lambda_na = res['lambda_na'] + self.t_lambda_na = res['t_lambda_na'] + self.i = res['i'] + self.t = res['t'] + self.t_dot = res['t_dot'] + self.epsilon = res['epsilon'] + self.omega = res['omega'] + return res, off, length + +SBP_MSG_ALMANAC_GLO = 0x0073 +class MsgAlmanacGlo(SBP): + """SBP class for message MSG_ALMANAC_GLO (0x0073). + + You can have MSG_ALMANAC_GLO inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The almanac message returns a set of satellite orbit parameters. Almanac +data is not very precise and is considered valid for up to several months. +Please see the GLO ICD 5.1 "Chapter 4.5 Non-immediate information and +almanac" for details. + + + """ + __slots__ = ['common', + 'lambda_na', + 't_lambda_na', + 'i', + 't', + 't_dot', + 'epsilon', + 'omega', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__common, offset, length) = offset, AlmanacCommonContent.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__lambda_na, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__t_lambda_na, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__i, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__t, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__t_dot, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__epsilon, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__omega, offset, length) = offset, get_f64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'common' : __common, + 'lambda_na' : __lambda_na, + 't_lambda_na' : __t_lambda_na, + 'i' : __i, + 't' : __t, + 't_dot' : __t_dot, + 'epsilon' : __epsilon, + 'omega' : __omega, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.common = res['common'] + self.lambda_na = res['lambda_na'] + self.t_lambda_na = res['t_lambda_na'] + self.i = res['i'] + self.t = res['t'] + self.t_dot = res['t_dot'] + self.epsilon = res['epsilon'] + self.omega = res['omega'] + return res, off, length + +SBP_MSG_GLO_BIASES = 0x0075 +class MsgGloBiases(SBP): + """SBP class for message MSG_GLO_BIASES (0x0075). + + You can have MSG_GLO_BIASES inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The GLONASS L1/L2 Code-Phase biases allows to perform +GPS+GLONASS integer ambiguity resolution for baselines +with mixed receiver types (e.g. receiver of different +manufacturers) + + + """ + __slots__ = ['mask', + 'l1ca_bias', + 'l1p_bias', + 'l2ca_bias', + 'l2p_bias', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__mask, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__l1ca_bias, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__l1p_bias, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__l2ca_bias, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__l2p_bias, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'mask' : __mask, + 'l1ca_bias' : __l1ca_bias, + 'l1p_bias' : __l1p_bias, + 'l2ca_bias' : __l2ca_bias, + 'l2p_bias' : __l2p_bias, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.mask = res['mask'] + self.l1ca_bias = res['l1ca_bias'] + self.l1p_bias = res['l1p_bias'] + self.l2ca_bias = res['l2ca_bias'] + self.l2p_bias = res['l2p_bias'] + return res, off, length + + +msg_classes = { + 0x004A: MsgObs, + 0x0044: MsgBasePosLLH, + 0x0048: MsgBasePosECEF, + 0x0081: MsgEphemerisGPSDepE, + 0x0086: MsgEphemerisGPSDepF, + 0x008A: MsgEphemerisGPS, + 0x0089: MsgEphemerisBds, + 0x0095: MsgEphemerisGal, + 0x0082: MsgEphemerisSbasDepA, + 0x0083: MsgEphemerisGloDepA, + 0x0084: MsgEphemerisSbasDepB, + 0x008C: MsgEphemerisSbas, + 0x0085: MsgEphemerisGloDepB, + 0x0087: MsgEphemerisGloDepC, + 0x0088: MsgEphemerisGloDepD, + 0x008B: MsgEphemerisGlo, + 0x0080: MsgEphemerisDepD, + 0x001A: MsgEphemerisDepA, + 0x0046: MsgEphemerisDepB, + 0x0047: MsgEphemerisDepC, + 0x0045: MsgObsDepA, + 0x0043: MsgObsDepB, + 0x0049: MsgObsDepC, + 0x0090: MsgIono, + 0x0091: MsgSvConfigurationGPSDep, + 0x0096: MsgGnssCapb, + 0x0092: MsgGroupDelayDepA, + 0x0093: MsgGroupDelayDepB, + 0x0094: MsgGroupDelay, + 0x0070: MsgAlmanacGPSDep, + 0x0072: MsgAlmanacGPS, + 0x0071: MsgAlmanacGloDep, + 0x0073: MsgAlmanacGlo, + 0x0075: MsgGloBiases, +} \ No newline at end of file diff --git a/python/sbp/jit/orientation.py b/python/sbp/jit/orientation.py new file mode 100644 index 0000000000..3740074e3f --- /dev/null +++ b/python/sbp/jit/orientation.py @@ -0,0 +1,319 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Orientation Messages +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array + +# Automatically generated from piksi/yaml/swiftnav/sbp/orientation.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_BASELINE_HEADING = 0x020F +class MsgBaselineHeading(SBP): + """SBP class for message MSG_BASELINE_HEADING (0x020F). + + You can have MSG_BASELINE_HEADING inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the baseline heading pointing from the base station +to the rover relative to True North. The full GPS time is given by the +preceding MSG_GPS_TIME with the matching time-of-week (tow). It is intended +that time-matched RTK mode is used when the base station is moving. + + + """ + __slots__ = ['tow', + 'heading', + 'n_sats', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__heading, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'heading' : __heading, + 'n_sats' : __n_sats, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.heading = res['heading'] + self.n_sats = res['n_sats'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_ORIENT_QUAT = 0x0220 +class MsgOrientQuat(SBP): + """SBP class for message MSG_ORIENT_QUAT (0x0220). + + You can have MSG_ORIENT_QUAT inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the quaternion vector describing the vehicle body frame's orientation +with respect to a local-level NED frame. The components of the vector should sum to a unit +vector assuming that the LSB of each component as a value of 2^-31. This message will only +be available in future INS versions of Swift Products and is not produced by Piksi Multi +or Duro. + + + """ + __slots__ = ['tow', + 'w', + 'x', + 'y', + 'z', + 'w_accuracy', + 'x_accuracy', + 'y_accuracy', + 'z_accuracy', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__w, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__x, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__y, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__z, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__w_accuracy, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__x_accuracy, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__y_accuracy, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__z_accuracy, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'w' : __w, + 'x' : __x, + 'y' : __y, + 'z' : __z, + 'w_accuracy' : __w_accuracy, + 'x_accuracy' : __x_accuracy, + 'y_accuracy' : __y_accuracy, + 'z_accuracy' : __z_accuracy, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.w = res['w'] + self.x = res['x'] + self.y = res['y'] + self.z = res['z'] + self.w_accuracy = res['w_accuracy'] + self.x_accuracy = res['x_accuracy'] + self.y_accuracy = res['y_accuracy'] + self.z_accuracy = res['z_accuracy'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_ORIENT_EULER = 0x0221 +class MsgOrientEuler(SBP): + """SBP class for message MSG_ORIENT_EULER (0x0221). + + You can have MSG_ORIENT_EULER inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the yaw, pitch, and roll angles of the vehicle body frame. +The rotations should applied intrinsically in the order yaw, pitch, and roll +in order to rotate the from a frame aligned with the local-level NED frame +to the vehicle body frame. This message will only be available in future +INS versions of Swift Products and is not produced by Piksi Multi or Duro. + + + """ + __slots__ = ['tow', + 'roll', + 'pitch', + 'yaw', + 'roll_accuracy', + 'pitch_accuracy', + 'yaw_accuracy', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__roll, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pitch, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__yaw, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__roll_accuracy, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pitch_accuracy, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__yaw_accuracy, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'roll' : __roll, + 'pitch' : __pitch, + 'yaw' : __yaw, + 'roll_accuracy' : __roll_accuracy, + 'pitch_accuracy' : __pitch_accuracy, + 'yaw_accuracy' : __yaw_accuracy, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.roll = res['roll'] + self.pitch = res['pitch'] + self.yaw = res['yaw'] + self.roll_accuracy = res['roll_accuracy'] + self.pitch_accuracy = res['pitch_accuracy'] + self.yaw_accuracy = res['yaw_accuracy'] + self.flags = res['flags'] + return res, off, length + +SBP_MSG_ANGULAR_RATE = 0x0222 +class MsgAngularRate(SBP): + """SBP class for message MSG_ANGULAR_RATE (0x0222). + + You can have MSG_ANGULAR_RATE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the orientation rates in the vehicle body frame. +The values represent the measurements a strapped down gyroscope would +make and are not equivalent to the time derivative of the Euler angles. +The orientation and origin of the user frame is specified via device settings. +By convention, the vehicle x-axis is expected to be aligned with the forward +direction, while the vehicle y-axis is expected to be aligned with the right +direction, and the vehicle z-axis should be aligned with the down direction. +This message will only be available in future INS versions of Swift Products +and is not produced by Piksi Multi or Duro. + + + """ + __slots__ = ['tow', + 'x', + 'y', + 'z', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__x, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__y, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__z, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'x' : __x, + 'y' : __y, + 'z' : __z, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.x = res['x'] + self.y = res['y'] + self.z = res['z'] + self.flags = res['flags'] + return res, off, length + + +msg_classes = { + 0x020F: MsgBaselineHeading, + 0x0220: MsgOrientQuat, + 0x0221: MsgOrientEuler, + 0x0222: MsgAngularRate, +} \ No newline at end of file diff --git a/python/sbp/jit/piksi.py b/python/sbp/jit/piksi.py new file mode 100644 index 0000000000..aacb052f2d --- /dev/null +++ b/python/sbp/jit/piksi.py @@ -0,0 +1,1252 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +System health, configuration, and diagnostic messages specific to +the Piksi L1 receiver, including a variety of legacy messages that +may no longer be used. + +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array +from sbp.jit.gnss import * + +# Automatically generated from piksi/yaml/swiftnav/sbp/piksi.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_ALMANAC = 0x0069 +class MsgAlmanac(SBP): + """SBP class for message MSG_ALMANAC (0x0069). + + You can have MSG_ALMANAC inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This is a legacy message for sending and loading a satellite +alamanac onto the Piksi's flash memory from the host. + + + """ + __slots__ = [] + +SBP_MSG_SET_TIME = 0x0068 +class MsgSetTime(SBP): + """SBP class for message MSG_SET_TIME (0x0068). + + You can have MSG_SET_TIME inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message sets up timing functionality using a coarse GPS +time estimate sent by the host. + + + """ + __slots__ = [] + +SBP_MSG_RESET = 0x00B6 +class MsgReset(SBP): + """SBP class for message MSG_RESET (0x00B6). + + You can have MSG_RESET inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message from the host resets the Piksi back into the +bootloader. + + + """ + __slots__ = ['flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__flags, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.flags = res['flags'] + return res, off, length + +SBP_MSG_RESET_DEP = 0x00B2 +class MsgResetDep(SBP): + """SBP class for message MSG_RESET_DEP (0x00B2). + + You can have MSG_RESET_DEP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message from the host resets the Piksi back into the +bootloader. + + + """ + __slots__ = [] + +SBP_MSG_CW_RESULTS = 0x00C0 +class MsgCwResults(SBP): + """SBP class for message MSG_CW_RESULTS (0x00C0). + + You can have MSG_CW_RESULTS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This is an unused legacy message for result reporting from the +CW interference channel on the SwiftNAP. This message will be +removed in a future release. + + + """ + __slots__ = [] + +SBP_MSG_CW_START = 0x00C1 +class MsgCwStart(SBP): + """SBP class for message MSG_CW_START (0x00C1). + + You can have MSG_CW_START inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This is an unused legacy message from the host for starting +the CW interference channel on the SwiftNAP. This message will +be removed in a future release. + + + """ + __slots__ = [] + +SBP_MSG_RESET_FILTERS = 0x0022 +class MsgResetFilters(SBP): + """SBP class for message MSG_RESET_FILTERS (0x0022). + + You can have MSG_RESET_FILTERS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message resets either the DGNSS Kalman filters or Integer +Ambiguity Resolution (IAR) process. + + + """ + __slots__ = ['filter', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__filter, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'filter' : __filter, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.filter = res['filter'] + return res, off, length + +SBP_MSG_INIT_BASE = 0x0023 +class MsgInitBase(SBP): + """SBP class for message MSG_INIT_BASE (0x0023). + + You can have MSG_INIT_BASE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message initializes the integer ambiguity resolution (IAR) +process on the Piksi to use an assumed baseline position between +the base station and rover receivers. Warns via MSG_PRINT if +there aren't a shared minimum number (4) of satellite +observations between the two. + + + """ + __slots__ = [] + +SBP_MSG_THREAD_STATE = 0x0017 +class MsgThreadState(SBP): + """SBP class for message MSG_THREAD_STATE (0x0017). + + You can have MSG_THREAD_STATE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The thread usage message from the device reports real-time +operating system (RTOS) thread usage statistics for the named +thread. The reported percentage values must be normalized. + + + """ + __slots__ = ['name', + 'cpu', + 'stack_free', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__name, offset, length) = offset, get_fixed_string(20)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cpu, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__stack_free, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'name' : __name, + 'cpu' : __cpu, + 'stack_free' : __stack_free, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.name = res['name'] + self.cpu = res['cpu'] + self.stack_free = res['stack_free'] + return res, off, length + +class UARTChannel(object): + """SBP class for message UARTChannel + + You can have UARTChannel inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Throughput, utilization, and error counts on the RX/TX buffers +of this UART channel. The reported percentage values must +be normalized. + + + """ + __slots__ = ['tx_throughput', + 'rx_throughput', + 'crc_error_count', + 'io_error_count', + 'tx_buffer_level', + 'rx_buffer_level', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tx_throughput, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__rx_throughput, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__crc_error_count, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__io_error_count, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tx_buffer_level, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__rx_buffer_level, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tx_throughput' : __tx_throughput, + 'rx_throughput' : __rx_throughput, + 'crc_error_count' : __crc_error_count, + 'io_error_count' : __io_error_count, + 'tx_buffer_level' : __tx_buffer_level, + 'rx_buffer_level' : __rx_buffer_level, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tx_throughput = res['tx_throughput'] + self.rx_throughput = res['rx_throughput'] + self.crc_error_count = res['crc_error_count'] + self.io_error_count = res['io_error_count'] + self.tx_buffer_level = res['tx_buffer_level'] + self.rx_buffer_level = res['rx_buffer_level'] + return res, off, length + +class Period(object): + """SBP class for message Period + + You can have Period inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Statistics on the period of observations received from the base +station. As complete observation sets are received, their time +of reception is compared with the prior set''s time of reception. +This measurement provides a proxy for link quality as incomplete +or missing sets will increase the period. Long periods +can cause momentary RTK solution outages. + + + """ + __slots__ = ['avg', + 'pmin', + 'pmax', + 'current', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__avg, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pmin, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pmax, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__current, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'avg' : __avg, + 'pmin' : __pmin, + 'pmax' : __pmax, + 'current' : __current, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.avg = res['avg'] + self.pmin = res['pmin'] + self.pmax = res['pmax'] + self.current = res['current'] + return res, off, length + +class Latency(object): + """SBP class for message Latency + + You can have Latency inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Statistics on the latency of observations received from the base +station. As observation packets are received their GPS time is +compared to the current GPS time calculated locally by the +receiver to give a precise measurement of the end-to-end +communication latency in the system. + + + """ + __slots__ = ['avg', + 'lmin', + 'lmax', + 'current', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__avg, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__lmin, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__lmax, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__current, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'avg' : __avg, + 'lmin' : __lmin, + 'lmax' : __lmax, + 'current' : __current, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.avg = res['avg'] + self.lmin = res['lmin'] + self.lmax = res['lmax'] + self.current = res['current'] + return res, off, length + +SBP_MSG_UART_STATE = 0x001D +class MsgUartState(SBP): + """SBP class for message MSG_UART_STATE (0x001D). + + You can have MSG_UART_STATE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The UART message reports data latency and throughput of the UART +channels providing SBP I/O. On the default Piksi configuration, +UARTs A and B are used for telemetry radios, but can also be +host access ports for embedded hosts, or other interfaces in +future. The reported percentage values must be normalized. +Observations latency and period can be used to assess the +health of the differential corrections link. Latency provides +the timeliness of received base observations while the +period indicates their likelihood of transmission. + + + """ + __slots__ = ['uart_a', + 'uart_b', + 'uart_ftdi', + 'latency', + 'obs_period', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__uart_a, offset, length) = offset, UARTChannel.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__uart_b, offset, length) = offset, UARTChannel.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__uart_ftdi, offset, length) = offset, UARTChannel.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__latency, offset, length) = offset, Latency.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__obs_period, offset, length) = offset, Period.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'uart_a' : __uart_a, + 'uart_b' : __uart_b, + 'uart_ftdi' : __uart_ftdi, + 'latency' : __latency, + 'obs_period' : __obs_period, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.uart_a = res['uart_a'] + self.uart_b = res['uart_b'] + self.uart_ftdi = res['uart_ftdi'] + self.latency = res['latency'] + self.obs_period = res['obs_period'] + return res, off, length + +SBP_MSG_UART_STATE_DEPA = 0x0018 +class MsgUartStateDepa(SBP): + """SBP class for message MSG_UART_STATE_DEPA (0x0018). + + You can have MSG_UART_STATE_DEPA inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated + + """ + __slots__ = ['uart_a', + 'uart_b', + 'uart_ftdi', + 'latency', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__uart_a, offset, length) = offset, UARTChannel.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__uart_b, offset, length) = offset, UARTChannel.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__uart_ftdi, offset, length) = offset, UARTChannel.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__latency, offset, length) = offset, Latency.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'uart_a' : __uart_a, + 'uart_b' : __uart_b, + 'uart_ftdi' : __uart_ftdi, + 'latency' : __latency, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.uart_a = res['uart_a'] + self.uart_b = res['uart_b'] + self.uart_ftdi = res['uart_ftdi'] + self.latency = res['latency'] + return res, off, length + +SBP_MSG_IAR_STATE = 0x0019 +class MsgIarState(SBP): + """SBP class for message MSG_IAR_STATE (0x0019). + + You can have MSG_IAR_STATE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message reports the state of the Integer Ambiguity +Resolution (IAR) process, which resolves unknown integer +ambiguities from double-differenced carrier-phase measurements +from satellite observations. + + + """ + __slots__ = ['num_hyps', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__num_hyps, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'num_hyps' : __num_hyps, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.num_hyps = res['num_hyps'] + return res, off, length + +SBP_MSG_MASK_SATELLITE = 0x002B +class MsgMaskSatellite(SBP): + """SBP class for message MSG_MASK_SATELLITE (0x002B). + + You can have MSG_MASK_SATELLITE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message allows setting a mask to prevent a particular satellite +from being used in various Piksi subsystems. + + + """ + __slots__ = ['mask', + 'sid', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__mask, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'mask' : __mask, + 'sid' : __sid, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.mask = res['mask'] + self.sid = res['sid'] + return res, off, length + +SBP_MSG_MASK_SATELLITE_DEP = 0x001B +class MsgMaskSatelliteDep(SBP): + """SBP class for message MSG_MASK_SATELLITE_DEP (0x001B). + + You can have MSG_MASK_SATELLITE_DEP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['mask', + 'sid', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__mask, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'mask' : __mask, + 'sid' : __sid, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.mask = res['mask'] + self.sid = res['sid'] + return res, off, length + +SBP_MSG_DEVICE_MONITOR = 0x00B5 +class MsgDeviceMonitor(SBP): + """SBP class for message MSG_DEVICE_MONITOR (0x00B5). + + You can have MSG_DEVICE_MONITOR inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message contains temperature and voltage level measurements from the +processor's monitoring system and the RF frontend die temperature if +available. + + + """ + __slots__ = ['dev_vin', + 'cpu_vint', + 'cpu_vaux', + 'cpu_temperature', + 'fe_temperature', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__dev_vin, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cpu_vint, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cpu_vaux, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cpu_temperature, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__fe_temperature, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'dev_vin' : __dev_vin, + 'cpu_vint' : __cpu_vint, + 'cpu_vaux' : __cpu_vaux, + 'cpu_temperature' : __cpu_temperature, + 'fe_temperature' : __fe_temperature, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.dev_vin = res['dev_vin'] + self.cpu_vint = res['cpu_vint'] + self.cpu_vaux = res['cpu_vaux'] + self.cpu_temperature = res['cpu_temperature'] + self.fe_temperature = res['fe_temperature'] + return res, off, length + +SBP_MSG_COMMAND_REQ = 0x00B8 +class MsgCommandReq(SBP): + """SBP class for message MSG_COMMAND_REQ (0x00B8). + + You can have MSG_COMMAND_REQ inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Request the recipient to execute an command. +Output will be sent in MSG_LOG messages, and the exit +code will be returned with MSG_COMMAND_RESP. + + + """ + __slots__ = ['sequence', + 'command', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__command, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sequence' : __sequence, + 'command' : __command, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sequence = res['sequence'] + self.command = res['command'] + return res, off, length + +SBP_MSG_COMMAND_RESP = 0x00B9 +class MsgCommandResp(SBP): + """SBP class for message MSG_COMMAND_RESP (0x00B9). + + You can have MSG_COMMAND_RESP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The response to MSG_COMMAND_REQ with the return code of +the command. A return code of zero indicates success. + + + """ + __slots__ = ['sequence', + 'code', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__code, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sequence' : __sequence, + 'code' : __code, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sequence = res['sequence'] + self.code = res['code'] + return res, off, length + +SBP_MSG_COMMAND_OUTPUT = 0x00BC +class MsgCommandOutput(SBP): + """SBP class for message MSG_COMMAND_OUTPUT (0x00BC). + + You can have MSG_COMMAND_OUTPUT inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Returns the standard output and standard error of the +command requested by MSG_COMMAND_REQ. +The sequence number can be used to filter for filtering +the correct command. + + + """ + __slots__ = ['sequence', + 'line', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__line, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sequence' : __sequence, + 'line' : __line, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sequence = res['sequence'] + self.line = res['line'] + return res, off, length + +SBP_MSG_NETWORK_STATE_REQ = 0x00BA +class MsgNetworkStateReq(SBP): + """SBP class for message MSG_NETWORK_STATE_REQ (0x00BA). + + You can have MSG_NETWORK_STATE_REQ inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Request state of Piksi network interfaces. +Output will be sent in MSG_NETWORK_STATE_RESP messages + + + """ + __slots__ = [] + +SBP_MSG_NETWORK_STATE_RESP = 0x00BB +class MsgNetworkStateResp(SBP): + """SBP class for message MSG_NETWORK_STATE_RESP (0x00BB). + + You can have MSG_NETWORK_STATE_RESP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The state of a network interface on the Piksi. +Data is made to reflect output of ifaddrs struct returned by getifaddrs +in c. + + + """ + __slots__ = ['ipv4_address', + 'ipv4_mask_size', + 'ipv6_address', + 'ipv6_mask_size', + 'rx_bytes', + 'tx_bytes', + 'interface_name', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__ipv4_address, offset, length) = offset, get_fixed_array(get_u8, 4, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ipv4_mask_size, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ipv6_address, offset, length) = offset, get_fixed_array(get_u8, 16, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__ipv6_mask_size, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__rx_bytes, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tx_bytes, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__interface_name, offset, length) = offset, get_fixed_string(16)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'ipv4_address' : __ipv4_address, + 'ipv4_mask_size' : __ipv4_mask_size, + 'ipv6_address' : __ipv6_address, + 'ipv6_mask_size' : __ipv6_mask_size, + 'rx_bytes' : __rx_bytes, + 'tx_bytes' : __tx_bytes, + 'interface_name' : __interface_name, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.ipv4_address = res['ipv4_address'] + self.ipv4_mask_size = res['ipv4_mask_size'] + self.ipv6_address = res['ipv6_address'] + self.ipv6_mask_size = res['ipv6_mask_size'] + self.rx_bytes = res['rx_bytes'] + self.tx_bytes = res['tx_bytes'] + self.interface_name = res['interface_name'] + self.flags = res['flags'] + return res, off, length + +class NetworkUsage(object): + """SBP class for message NetworkUsage + + You can have NetworkUsage inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The bandwidth usage for each interface can be reported +within this struct and utilize multiple fields to fully +specify the type of traffic that is being tracked. As +either the interval of collection or the collection time +may vary, both a timestamp and period field is provided, +though may not necessarily be populated with a value. + + + """ + __slots__ = ['duration', + 'total_bytes', + 'rx_bytes', + 'tx_bytes', + 'interface_name', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__duration, offset, length) = offset, get_u64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__total_bytes, offset, length) = offset, get_u64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__rx_bytes, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tx_bytes, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__interface_name, offset, length) = offset, get_fixed_string(16)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'duration' : __duration, + 'total_bytes' : __total_bytes, + 'rx_bytes' : __rx_bytes, + 'tx_bytes' : __tx_bytes, + 'interface_name' : __interface_name, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.duration = res['duration'] + self.total_bytes = res['total_bytes'] + self.rx_bytes = res['rx_bytes'] + self.tx_bytes = res['tx_bytes'] + self.interface_name = res['interface_name'] + return res, off, length + +SBP_MSG_NETWORK_BANDWIDTH_USAGE = 0x00BD +class MsgNetworkBandwidthUsage(SBP): + """SBP class for message MSG_NETWORK_BANDWIDTH_USAGE (0x00BD). + + You can have MSG_NETWORK_BANDWIDTH_USAGE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The bandwidth usage, a list of usage by interface. + + + """ + __slots__ = ['interfaces', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__interfaces, offset, length) = offset, get_array(NetworkUsage.parse_members)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'interfaces' : __interfaces, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.interfaces = res['interfaces'] + return res, off, length + +SBP_MSG_CELL_MODEM_STATUS = 0x00BE +class MsgCellModemStatus(SBP): + """SBP class for message MSG_CELL_MODEM_STATUS (0x00BE). + + You can have MSG_CELL_MODEM_STATUS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + If a cell modem is present on a piksi device, this message +will be send periodically to update the host on the status +of the modem and its various parameters. + + + """ + __slots__ = ['signal_strength', + 'signal_error_rate', + 'reserved', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__signal_strength, offset, length) = offset, get_s8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__signal_error_rate, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__reserved, offset, length) = offset, get_array(get_u8)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'signal_strength' : __signal_strength, + 'signal_error_rate' : __signal_error_rate, + 'reserved' : __reserved, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.signal_strength = res['signal_strength'] + self.signal_error_rate = res['signal_error_rate'] + self.reserved = res['reserved'] + return res, off, length + +SBP_MSG_SPECAN_DEP = 0x0050 +class MsgSpecanDep(SBP): + """SBP class for message MSG_SPECAN_DEP (0x0050). + + You can have MSG_SPECAN_DEP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['channel_tag', + 't', + 'freq_ref', + 'freq_step', + 'amplitude_ref', + 'amplitude_unit', + 'amplitude_value', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__channel_tag, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__t, offset, length) = offset, GPSTimeDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__freq_ref, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__freq_step, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__amplitude_ref, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__amplitude_unit, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__amplitude_value, offset, length) = offset, get_array(get_u8)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'channel_tag' : __channel_tag, + 't' : __t, + 'freq_ref' : __freq_ref, + 'freq_step' : __freq_step, + 'amplitude_ref' : __amplitude_ref, + 'amplitude_unit' : __amplitude_unit, + 'amplitude_value' : __amplitude_value, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.channel_tag = res['channel_tag'] + self.t = res['t'] + self.freq_ref = res['freq_ref'] + self.freq_step = res['freq_step'] + self.amplitude_ref = res['amplitude_ref'] + self.amplitude_unit = res['amplitude_unit'] + self.amplitude_value = res['amplitude_value'] + return res, off, length + +SBP_MSG_SPECAN = 0x0051 +class MsgSpecan(SBP): + """SBP class for message MSG_SPECAN (0x0051). + + You can have MSG_SPECAN inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Spectrum analyzer packet. + + + """ + __slots__ = ['channel_tag', + 't', + 'freq_ref', + 'freq_step', + 'amplitude_ref', + 'amplitude_unit', + 'amplitude_value', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__channel_tag, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__t, offset, length) = offset, GPSTime.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__freq_ref, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__freq_step, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__amplitude_ref, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__amplitude_unit, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__amplitude_value, offset, length) = offset, get_array(get_u8)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'channel_tag' : __channel_tag, + 't' : __t, + 'freq_ref' : __freq_ref, + 'freq_step' : __freq_step, + 'amplitude_ref' : __amplitude_ref, + 'amplitude_unit' : __amplitude_unit, + 'amplitude_value' : __amplitude_value, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.channel_tag = res['channel_tag'] + self.t = res['t'] + self.freq_ref = res['freq_ref'] + self.freq_step = res['freq_step'] + self.amplitude_ref = res['amplitude_ref'] + self.amplitude_unit = res['amplitude_unit'] + self.amplitude_value = res['amplitude_value'] + return res, off, length + +SBP_MSG_FRONT_END_GAIN = 0x00BF +class MsgFrontEndGain(SBP): + """SBP class for message MSG_FRONT_END_GAIN (0x00BF). + + You can have MSG_FRONT_END_GAIN inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message describes the gain of each channel in the receiver frontend. Each +gain is encoded as a non-dimensional percentage relative to the maximum range +possible for the gain stage of the frontend. By convention, each gain array +has 8 entries and the index of the array corresponding to the index of the rf channel +in the frontend. A gain of 127 percent encodes that rf channel is not present in the hardware. +A negative value implies an error for the particular gain stage as reported by the frontend. + + + """ + __slots__ = ['rf_gain', + 'if_gain', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__rf_gain, offset, length) = offset, get_fixed_array(get_u8, 8, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__if_gain, offset, length) = offset, get_fixed_array(get_u8, 8, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'rf_gain' : __rf_gain, + 'if_gain' : __if_gain, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.rf_gain = res['rf_gain'] + self.if_gain = res['if_gain'] + return res, off, length + + +msg_classes = { + 0x0069: MsgAlmanac, + 0x0068: MsgSetTime, + 0x00B6: MsgReset, + 0x00B2: MsgResetDep, + 0x00C0: MsgCwResults, + 0x00C1: MsgCwStart, + 0x0022: MsgResetFilters, + 0x0023: MsgInitBase, + 0x0017: MsgThreadState, + 0x001D: MsgUartState, + 0x0018: MsgUartStateDepa, + 0x0019: MsgIarState, + 0x002B: MsgMaskSatellite, + 0x001B: MsgMaskSatelliteDep, + 0x00B5: MsgDeviceMonitor, + 0x00B8: MsgCommandReq, + 0x00B9: MsgCommandResp, + 0x00BC: MsgCommandOutput, + 0x00BA: MsgNetworkStateReq, + 0x00BB: MsgNetworkStateResp, + 0x00BD: MsgNetworkBandwidthUsage, + 0x00BE: MsgCellModemStatus, + 0x0050: MsgSpecanDep, + 0x0051: MsgSpecan, + 0x00BF: MsgFrontEndGain, +} \ No newline at end of file diff --git a/python/sbp/jit/sbas.py b/python/sbp/jit/sbas.py new file mode 100644 index 0000000000..73d499bfb7 --- /dev/null +++ b/python/sbp/jit/sbas.py @@ -0,0 +1,83 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +SBAS data +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array +from sbp.jit.gnss import * + +# Automatically generated from piksi/yaml/swiftnav/sbp/sbas.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_SBAS_RAW = 0x7777 +class MsgSbasRaw(SBP): + """SBP class for message MSG_SBAS_RAW (0x7777). + + You can have MSG_SBAS_RAW inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message is sent once per second per SBAS satellite. ME checks the +parity of the data block and sends only blocks that pass the check. + + + """ + __slots__ = ['sid', + 'tow', + 'message_type', + 'data', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__message_type, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__data, offset, length) = offset, get_fixed_array(get_u8, 27, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sid' : __sid, + 'tow' : __tow, + 'message_type' : __message_type, + 'data' : __data, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sid = res['sid'] + self.tow = res['tow'] + self.message_type = res['message_type'] + self.data = res['data'] + return res, off, length + + +msg_classes = { + 0x7777: MsgSbasRaw, +} \ No newline at end of file diff --git a/python/sbp/jit/settings.py b/python/sbp/jit/settings.py new file mode 100644 index 0000000000..637658cb51 --- /dev/null +++ b/python/sbp/jit/settings.py @@ -0,0 +1,412 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" + +Messages for reading, writing, and discovering device settings. Settings +with a "string" field have multiple values in this field delimited with a +null character (the c style null terminator). For instance, when querying +the 'firmware_version' setting in the 'system_info' section, the following +array of characters needs to be sent for the string field in +MSG_SETTINGS_READ: "system_info\0firmware_version\0", where the delimiting +null characters are specified with the escape sequence '\0' and all +quotation marks should be omitted. + + +In the message descriptions below, the generic strings SECTION_SETTING and +SETTING are used to refer to the two strings that comprise the identifier +of an individual setting.In firmware_version example above, SECTION_SETTING +is the 'system_info', and the SETTING portion is 'firmware_version'. + +See the "Software Settings Manual" on support.swiftnav.com for detailed +documentation about all settings and sections available for each Swift +firmware version. Settings manuals are available for each firmware version +at the following link: https://support.swiftnav.com/customer/en/portal/articles/2628580-piksi-multi-specifications#settings. +The latest settings document is also available at the following link: +http://swiftnav.com/latest/piksi-multi-settings . +See lastly https://github.com/swift-nav/piksi_tools/blob/master/piksi_tools/settings.py , +the open source python command line utility for reading, writing, and +saving settings in the piksi_tools repository on github as a helpful +reference and example. + +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array + +# Automatically generated from piksi/yaml/swiftnav/sbp/settings.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_SETTINGS_SAVE = 0x00A1 +class MsgSettingsSave(SBP): + """SBP class for message MSG_SETTINGS_SAVE (0x00A1). + + You can have MSG_SETTINGS_SAVE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The save settings message persists the device's current settings +configuration to its onboard flash memory file system. + + + """ + __slots__ = [] + +SBP_MSG_SETTINGS_WRITE = 0x00A0 +class MsgSettingsWrite(SBP): + """SBP class for message MSG_SETTINGS_WRITE (0x00A0). + + You can have MSG_SETTINGS_WRITE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The setting message writes the device configuration for a particular +setting via A NULL-terminated and NULL-delimited string with contents +"SECTION_SETTING\0SETTING\0VALUE\0" where the '\0' escape sequence denotes +the NULL character and where quotation marks are omitted. A device will +only process to this message when it is received from sender ID 0x42. +An example string that could be sent to a device is +"solution\0soln_freq\010\0". + + + """ + __slots__ = ['setting', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__setting, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'setting' : __setting, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.setting = res['setting'] + return res, off, length + +SBP_MSG_SETTINGS_WRITE_RESP = 0x00AF +class MsgSettingsWriteResp(SBP): + """SBP class for message MSG_SETTINGS_WRITE_RESP (0x00AF). + + You can have MSG_SETTINGS_WRITE_RESP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Return the status of a write request with the new value of the +setting. If the requested value is rejected, the current value +will be returned. The string field is a NULL-terminated and NULL-delimited +string with contents "SECTION_SETTING\0SETTING\0VALUE\0" where the '\0' +escape sequence denotes the NULL character and where quotation marks +are omitted. An example string that could be sent from device is +"solution\0soln_freq\010\0". + + + """ + __slots__ = ['status', + 'setting', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__status, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__setting, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'status' : __status, + 'setting' : __setting, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.status = res['status'] + self.setting = res['setting'] + return res, off, length + +SBP_MSG_SETTINGS_READ_REQ = 0x00A4 +class MsgSettingsReadReq(SBP): + """SBP class for message MSG_SETTINGS_READ_REQ (0x00A4). + + You can have MSG_SETTINGS_READ_REQ inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The setting message that reads the device configuration. The string +field is a NULL-terminated and NULL-delimited string with contents +"SECTION_SETTING\0SETTING\0" where the '\0' escape sequence denotes the +NULL character and where quotation marks are omitted. An example +string that could be sent to a device is "solution\0soln_freq\0". A +device will only respond to this message when it is received from +sender ID 0x42. A device should respond with a MSG_SETTINGS_READ_RESP +message (msg_id 0x00A5). + + + """ + __slots__ = ['setting', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__setting, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'setting' : __setting, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.setting = res['setting'] + return res, off, length + +SBP_MSG_SETTINGS_READ_RESP = 0x00A5 +class MsgSettingsReadResp(SBP): + """SBP class for message MSG_SETTINGS_READ_RESP (0x00A5). + + You can have MSG_SETTINGS_READ_RESP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The setting message wich which the device responds after a +MSG_SETTING_READ_REQ is sent to device. The string field is a +NULL-terminated and NULL-delimited string with contents +"SECTION_SETTING\0SETTING\0VALUE\0" where the '\0' escape sequence +denotes the NULL character and where quotation marks are omitted. An +example string that could be sent from device is +"solution\0soln_freq\010\0". + + + """ + __slots__ = ['setting', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__setting, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'setting' : __setting, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.setting = res['setting'] + return res, off, length + +SBP_MSG_SETTINGS_READ_BY_INDEX_REQ = 0x00A2 +class MsgSettingsReadByIndexReq(SBP): + """SBP class for message MSG_SETTINGS_READ_BY_INDEX_REQ (0x00A2). + + You can have MSG_SETTINGS_READ_BY_INDEX_REQ inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The settings message for iterating through the settings +values. A device will respond to this message with a +"MSG_SETTINGS_READ_BY_INDEX_RESP". + + + """ + __slots__ = ['index', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__index, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'index' : __index, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.index = res['index'] + return res, off, length + +SBP_MSG_SETTINGS_READ_BY_INDEX_RESP = 0x00A7 +class MsgSettingsReadByIndexResp(SBP): + """SBP class for message MSG_SETTINGS_READ_BY_INDEX_RESP (0x00A7). + + You can have MSG_SETTINGS_READ_BY_INDEX_RESP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The settings message that reports the value of a setting at an index. + +In the string field, it reports NULL-terminated and delimited string +with contents "SECTION_SETTING\0SETTING\0VALUE\0FORMAT_TYPE\0". where +the '\0' escape sequence denotes the NULL character and where quotation +marks are omitted. The FORMAT_TYPE field is optional and denotes +possible string values of the setting as a hint to the user. If +included, the format type portion of the string has the format +"enum:value1,value2,value3". An example string that could be sent from +the device is "simulator\0enabled\0True\0enum:True,False\0" + + + """ + __slots__ = ['index', + 'setting', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__index, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__setting, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'index' : __index, + 'setting' : __setting, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.index = res['index'] + self.setting = res['setting'] + return res, off, length + +SBP_MSG_SETTINGS_READ_BY_INDEX_DONE = 0x00A6 +class MsgSettingsReadByIndexDone(SBP): + """SBP class for message MSG_SETTINGS_READ_BY_INDEX_DONE (0x00A6). + + You can have MSG_SETTINGS_READ_BY_INDEX_DONE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The settings message for indicating end of the settings values. + + + """ + __slots__ = [] + +SBP_MSG_SETTINGS_REGISTER = 0x00AE +class MsgSettingsRegister(SBP): + """SBP class for message MSG_SETTINGS_REGISTER (0x00AE). + + You can have MSG_SETTINGS_REGISTER inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message registers the presence and default value of a setting +with a settings daemon. The host should reply with MSG_SETTINGS_WRITE +for this setting to set the initial value. + + + """ + __slots__ = ['setting', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__setting, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'setting' : __setting, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.setting = res['setting'] + return res, off, length + +SBP_MSG_SETTINGS_REGISTER_RESP = 0x01AF +class MsgSettingsRegisterResp(SBP): + """SBP class for message MSG_SETTINGS_REGISTER_RESP (0x01AF). + + You can have MSG_SETTINGS_REGISTER_RESP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message responds to setting registration with the effective value. +The effective value shall differ from the given default value if setting +was already registered or is available in the permanent setting storage +and had a different value. + + + """ + __slots__ = ['status', + 'setting', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__status, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__setting, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'status' : __status, + 'setting' : __setting, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.status = res['status'] + self.setting = res['setting'] + return res, off, length + + +msg_classes = { + 0x00A1: MsgSettingsSave, + 0x00A0: MsgSettingsWrite, + 0x00AF: MsgSettingsWriteResp, + 0x00A4: MsgSettingsReadReq, + 0x00A5: MsgSettingsReadResp, + 0x00A2: MsgSettingsReadByIndexReq, + 0x00A7: MsgSettingsReadByIndexResp, + 0x00A6: MsgSettingsReadByIndexDone, + 0x00AE: MsgSettingsRegister, + 0x01AF: MsgSettingsRegisterResp, +} \ No newline at end of file diff --git a/python/sbp/jit/ssr.py b/python/sbp/jit/ssr.py new file mode 100644 index 0000000000..671955ea95 --- /dev/null +++ b/python/sbp/jit/ssr.py @@ -0,0 +1,499 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Precise State Space Representation (SSR) corrections format +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array +from sbp.jit.gnss import * + +# Automatically generated from piksi/yaml/swiftnav/sbp/ssr.yaml with generate.py. +# Please do not hand edit! +class CodeBiasesContent(object): + """SBP class for message CodeBiasesContent + + You can have CodeBiasesContent inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Code biases are to be added to pseudorange. +The corrections are conform with typical RTCMv3 MT1059 and 1065. + + + """ + __slots__ = ['code', + 'value', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__code, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__value, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'code' : __code, + 'value' : __value, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.code = res['code'] + self.value = res['value'] + return res, off, length + +class PhaseBiasesContent(object): + """SBP class for message PhaseBiasesContent + + You can have PhaseBiasesContent inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Phase biases are to be added to carrier phase measurements. +The corrections are conform with typical RTCMv3 MT1059 and 1065. + + + """ + __slots__ = ['code', + 'integer_indicator', + 'widelane_integer_indicator', + 'discontinuity_counter', + 'bias', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__code, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__integer_indicator, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__widelane_integer_indicator, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__discontinuity_counter, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__bias, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'code' : __code, + 'integer_indicator' : __integer_indicator, + 'widelane_integer_indicator' : __widelane_integer_indicator, + 'discontinuity_counter' : __discontinuity_counter, + 'bias' : __bias, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.code = res['code'] + self.integer_indicator = res['integer_indicator'] + self.widelane_integer_indicator = res['widelane_integer_indicator'] + self.discontinuity_counter = res['discontinuity_counter'] + self.bias = res['bias'] + return res, off, length + +SBP_MSG_SSR_ORBIT_CLOCK = 0x05DD +class MsgSsrOrbitClock(SBP): + """SBP class for message MSG_SSR_ORBIT_CLOCK (0x05DD). + + You can have MSG_SSR_ORBIT_CLOCK inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The precise orbit and clock correction message is +to be applied as a delta correction to broadcast +ephemeris and is typically an equivalent to the 1060 +and 1066 RTCM message types + + + """ + __slots__ = ['time', + 'sid', + 'update_interval', + 'iod_ssr', + 'iod', + 'radial', + 'along', + 'cross', + 'dot_radial', + 'dot_along', + 'dot_cross', + 'c0', + 'c1', + 'c2', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__time, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__update_interval, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iod_ssr, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iod, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__radial, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__along, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cross, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__dot_radial, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__dot_along, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__dot_cross, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c0, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c1, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c2, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'time' : __time, + 'sid' : __sid, + 'update_interval' : __update_interval, + 'iod_ssr' : __iod_ssr, + 'iod' : __iod, + 'radial' : __radial, + 'along' : __along, + 'cross' : __cross, + 'dot_radial' : __dot_radial, + 'dot_along' : __dot_along, + 'dot_cross' : __dot_cross, + 'c0' : __c0, + 'c1' : __c1, + 'c2' : __c2, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.time = res['time'] + self.sid = res['sid'] + self.update_interval = res['update_interval'] + self.iod_ssr = res['iod_ssr'] + self.iod = res['iod'] + self.radial = res['radial'] + self.along = res['along'] + self.cross = res['cross'] + self.dot_radial = res['dot_radial'] + self.dot_along = res['dot_along'] + self.dot_cross = res['dot_cross'] + self.c0 = res['c0'] + self.c1 = res['c1'] + self.c2 = res['c2'] + return res, off, length + +SBP_MSG_SSR_ORBIT_CLOCK_DEP_A = 0x05DC +class MsgSsrOrbitClockDepA(SBP): + """SBP class for message MSG_SSR_ORBIT_CLOCK_DEP_A (0x05DC). + + You can have MSG_SSR_ORBIT_CLOCK_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The precise orbit and clock correction message is +to be applied as a delta correction to broadcast +ephemeris and is typically an equivalent to the 1060 +and 1066 RTCM message types + + + """ + __slots__ = ['time', + 'sid', + 'update_interval', + 'iod_ssr', + 'iod', + 'radial', + 'along', + 'cross', + 'dot_radial', + 'dot_along', + 'dot_cross', + 'c0', + 'c1', + 'c2', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__time, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__update_interval, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iod_ssr, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iod, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__radial, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__along, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cross, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__dot_radial, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__dot_along, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__dot_cross, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c0, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c1, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__c2, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'time' : __time, + 'sid' : __sid, + 'update_interval' : __update_interval, + 'iod_ssr' : __iod_ssr, + 'iod' : __iod, + 'radial' : __radial, + 'along' : __along, + 'cross' : __cross, + 'dot_radial' : __dot_radial, + 'dot_along' : __dot_along, + 'dot_cross' : __dot_cross, + 'c0' : __c0, + 'c1' : __c1, + 'c2' : __c2, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.time = res['time'] + self.sid = res['sid'] + self.update_interval = res['update_interval'] + self.iod_ssr = res['iod_ssr'] + self.iod = res['iod'] + self.radial = res['radial'] + self.along = res['along'] + self.cross = res['cross'] + self.dot_radial = res['dot_radial'] + self.dot_along = res['dot_along'] + self.dot_cross = res['dot_cross'] + self.c0 = res['c0'] + self.c1 = res['c1'] + self.c2 = res['c2'] + return res, off, length + +SBP_MSG_SSR_CODE_BIASES = 0x05E1 +class MsgSsrCodeBiases(SBP): + """SBP class for message MSG_SSR_CODE_BIASES (0x05E1). + + You can have MSG_SSR_CODE_BIASES inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The precise code biases message is to be added +to the pseudorange of the corresponding signal +to get corrected pseudorange. It is typically +an equivalent to the 1059 and 1065 RTCM message types + + + """ + __slots__ = ['time', + 'sid', + 'update_interval', + 'iod_ssr', + 'biases', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__time, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__update_interval, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iod_ssr, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__biases, offset, length) = offset, get_array(CodeBiasesContent.parse_members)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'time' : __time, + 'sid' : __sid, + 'update_interval' : __update_interval, + 'iod_ssr' : __iod_ssr, + 'biases' : __biases, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.time = res['time'] + self.sid = res['sid'] + self.update_interval = res['update_interval'] + self.iod_ssr = res['iod_ssr'] + self.biases = res['biases'] + return res, off, length + +SBP_MSG_SSR_PHASE_BIASES = 0x05E6 +class MsgSsrPhaseBiases(SBP): + """SBP class for message MSG_SSR_PHASE_BIASES (0x05E6). + + You can have MSG_SSR_PHASE_BIASES inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The precise phase biases message contains the biases +to be added to the carrier phase of the corresponding +signal to get corrected carrier phase measurement, as +well as the satellite yaw angle to be applied to compute +the phase wind-up correction. +It is typically an equivalent to the 1265 RTCM message types + + + """ + __slots__ = ['time', + 'sid', + 'update_interval', + 'iod_ssr', + 'dispersive_bias', + 'mw_consistency', + 'yaw', + 'yaw_rate', + 'biases', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__time, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__update_interval, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__iod_ssr, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__dispersive_bias, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__mw_consistency, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__yaw, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__yaw_rate, offset, length) = offset, get_s8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__biases, offset, length) = offset, get_array(PhaseBiasesContent.parse_members)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'time' : __time, + 'sid' : __sid, + 'update_interval' : __update_interval, + 'iod_ssr' : __iod_ssr, + 'dispersive_bias' : __dispersive_bias, + 'mw_consistency' : __mw_consistency, + 'yaw' : __yaw, + 'yaw_rate' : __yaw_rate, + 'biases' : __biases, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.time = res['time'] + self.sid = res['sid'] + self.update_interval = res['update_interval'] + self.iod_ssr = res['iod_ssr'] + self.dispersive_bias = res['dispersive_bias'] + self.mw_consistency = res['mw_consistency'] + self.yaw = res['yaw'] + self.yaw_rate = res['yaw_rate'] + self.biases = res['biases'] + return res, off, length + + +msg_classes = { + 0x05DD: MsgSsrOrbitClock, + 0x05DC: MsgSsrOrbitClockDepA, + 0x05E1: MsgSsrCodeBiases, + 0x05E6: MsgSsrPhaseBiases, +} \ No newline at end of file diff --git a/python/sbp/jit/system.py b/python/sbp/jit/system.py new file mode 100644 index 0000000000..ff3d0d4416 --- /dev/null +++ b/python/sbp/jit/system.py @@ -0,0 +1,289 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Standardized system messages from Swift Navigation devices. +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array + +# Automatically generated from piksi/yaml/swiftnav/sbp/system.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_STARTUP = 0xFF00 +class MsgStartup(SBP): + """SBP class for message MSG_STARTUP (0xFF00). + + You can have MSG_STARTUP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The system start-up message is sent once on system +start-up. It notifies the host or other attached devices that +the system has started and is now ready to respond to commands +or configuration requests. + + + """ + __slots__ = ['cause', + 'startup_type', + 'reserved', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__cause, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__startup_type, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__reserved, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'cause' : __cause, + 'startup_type' : __startup_type, + 'reserved' : __reserved, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.cause = res['cause'] + self.startup_type = res['startup_type'] + self.reserved = res['reserved'] + return res, off, length + +SBP_MSG_DGNSS_STATUS = 0xFF02 +class MsgDgnssStatus(SBP): + """SBP class for message MSG_DGNSS_STATUS (0xFF02). + + You can have MSG_DGNSS_STATUS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message provides information about the receipt of Differential +corrections. It is expected to be sent with each receipt of a complete +corrections packet. + + + """ + __slots__ = ['flags', + 'latency', + 'num_signals', + 'source', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__latency, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__num_signals, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__source, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'flags' : __flags, + 'latency' : __latency, + 'num_signals' : __num_signals, + 'source' : __source, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.flags = res['flags'] + self.latency = res['latency'] + self.num_signals = res['num_signals'] + self.source = res['source'] + return res, off, length + +SBP_MSG_HEARTBEAT = 0xFFFF +class MsgHeartbeat(SBP): + """SBP class for message MSG_HEARTBEAT (0xFFFF). + + You can have MSG_HEARTBEAT inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The heartbeat message is sent periodically to inform the host +or other attached devices that the system is running. It is +used to monitor system malfunctions. It also contains status +flags that indicate to the host the status of the system and +whether it is operating correctly. Currently, the expected +heartbeat interval is 1 sec. + +The system error flag is used to indicate that an error has +occurred in the system. To determine the source of the error, +the remaining error flags should be inspected. + + + """ + __slots__ = ['flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__flags, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.flags = res['flags'] + return res, off, length + +SBP_MSG_INS_STATUS = 0xFF03 +class MsgInsStatus(SBP): + """SBP class for message MSG_INS_STATUS (0xFF03). + + You can have MSG_INS_STATUS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The INS status message describes the state of the operation +and initialization of the inertial navigation system. + + + """ + __slots__ = ['flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__flags, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.flags = res['flags'] + return res, off, length + +SBP_MSG_CSAC_TELEMETRY = 0xFF04 +class MsgCsacTelemetry(SBP): + """SBP class for message MSG_CSAC_TELEMETRY (0xFF04). + + You can have MSG_CSAC_TELEMETRY inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The CSAC telemetry message has an implementation defined telemetry string +from a device. It is not produced or available on general Swift Products. +It is intended to be a low rate message for status purposes. + + + """ + __slots__ = ['id', + 'telemetry', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__id, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__telemetry, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'id' : __id, + 'telemetry' : __telemetry, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.id = res['id'] + self.telemetry = res['telemetry'] + return res, off, length + +SBP_MSG_CSAC_TELEMETRY_LABELS = 0xFF05 +class MsgCsacTelemetryLabels(SBP): + """SBP class for message MSG_CSAC_TELEMETRY_LABELS (0xFF05). + + You can have MSG_CSAC_TELEMETRY_LABELS inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The CSAC telemetry message provides labels for each member of the string +produced by MSG_CSAC_TELEMETRY. It should be provided by a device at a lower +rate than the MSG_CSAC_TELEMETRY. + + + """ + __slots__ = ['id', + 'telemetry_labels', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__id, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__telemetry_labels, offset, length) = offset, get_string(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'id' : __id, + 'telemetry_labels' : __telemetry_labels, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.id = res['id'] + self.telemetry_labels = res['telemetry_labels'] + return res, off, length + + +msg_classes = { + 0xFF00: MsgStartup, + 0xFF02: MsgDgnssStatus, + 0xFFFF: MsgHeartbeat, + 0xFF03: MsgInsStatus, + 0xFF04: MsgCsacTelemetry, + 0xFF05: MsgCsacTelemetryLabels, +} \ No newline at end of file diff --git a/python/sbp/jit/table.py b/python/sbp/jit/table.py new file mode 100755 index 0000000000..22dc20ca55 --- /dev/null +++ b/python/sbp/jit/table.py @@ -0,0 +1,88 @@ +#!/usr/bin/env python +# Copyright (C) 2011-2014 Swift Navigation Inc. +# Contact: Bhaskar Mookerji +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +""" +Single dispatch of available SBP messages, keyed by msg_type. + +""" + +from sbp.jit import acquisition as acq +from sbp.jit import bootload as boot +from sbp.jit import file_io as file_io +from sbp.jit import flash as flash +from sbp.jit import linux as linux +from sbp.jit import logging as log +from sbp.jit import navigation as nav +from sbp.jit import observation as obs +from sbp.jit import piksi as piksi +from sbp.jit import settings as settings +from sbp.jit import system as sys +from sbp.jit import tracking as trac +from sbp.jit import ext_events as ext_events +from sbp.jit import user as user +from sbp.jit import imu as imu +from sbp.jit import mag as mag +from sbp.jit import ndb as ndb +from sbp.jit import vehicle as vehicle +from sbp.jit import orientation as orientation +from sbp.jit import sbas as sbas +from sbp.jit import ssr as ssr + + +_SBP_TABLE = dict(list(acq.msg_classes.items()) + + list(boot.msg_classes.items()) + + list(file_io.msg_classes.items()) + + list(flash.msg_classes.items()) + + list(linux.msg_classes.items()) + + list(log.msg_classes.items()) + + list(nav.msg_classes.items()) + + list(obs.msg_classes.items()) + + list(piksi.msg_classes.items()) + + list(settings.msg_classes.items()) + + list(sys.msg_classes.items()) + + list(trac.msg_classes.items()) + + list(user.msg_classes.items()) + + list(imu.msg_classes.items()) + + list(mag.msg_classes.items()) + + list(ext_events.msg_classes.items()) + + list(ndb.msg_classes.items()) + + list(vehicle.msg_classes.items()) + + list(orientation.msg_classes.items()) + + list(sbas.msg_classes.items()) + + list(ssr.msg_classes.items()) + ) + + +class InvalidSBPMessageType(NotImplementedError): + """ + Base exception for messages with invalid message types. + """ + + +def dispatch(msg_type, table=_SBP_TABLE): + """ + Dispatch an SBP message type based on its `msg_type` and parse its + payload. + + Parameters + ---------- + driver : :class:`SBP` + A parsed SBP object. + table : dict + Any table mapping unique SBP message type IDs to SBP message + constructors. + + Returns + ---------- + SBP message with a parsed payload. + + """ + return table[msg_type] diff --git a/python/sbp/jit/tracking.py b/python/sbp/jit/tracking.py new file mode 100644 index 0000000000..497a8111eb --- /dev/null +++ b/python/sbp/jit/tracking.py @@ -0,0 +1,768 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Satellite code and carrier-phase tracking messages from the device. + +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array +from sbp.jit.gnss import * + +# Automatically generated from piksi/yaml/swiftnav/sbp/tracking.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_TRACKING_STATE_DETAILED_DEP_A = 0x0021 +class MsgTrackingStateDetailedDepA(SBP): + """SBP class for message MSG_TRACKING_STATE_DETAILED_DEP_A (0x0021). + + You can have MSG_TRACKING_STATE_DETAILED_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The tracking message returns a set tracking channel parameters for a +single tracking channel useful for debugging issues. + + + """ + __slots__ = ['recv_time', + 'tot', + 'P', + 'P_std', + 'L', + 'cn0', + 'lock', + 'sid', + 'doppler', + 'doppler_std', + 'uptime', + 'clock_offset', + 'clock_drift', + 'corr_spacing', + 'acceleration', + 'sync_flags', + 'tow_flags', + 'track_flags', + 'nav_flags', + 'pset_flags', + 'misc_flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__recv_time, offset, length) = offset, get_u64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tot, offset, length) = offset, GPSTime.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__P, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__P_std, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__L, offset, length) = offset, CarrierPhase.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cn0, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__lock, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__doppler, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__doppler_std, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__uptime, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__clock_offset, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__clock_drift, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__corr_spacing, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__acceleration, offset, length) = offset, get_s8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sync_flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tow_flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__track_flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__nav_flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pset_flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__misc_flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'recv_time' : __recv_time, + 'tot' : __tot, + 'P' : __P, + 'P_std' : __P_std, + 'L' : __L, + 'cn0' : __cn0, + 'lock' : __lock, + 'sid' : __sid, + 'doppler' : __doppler, + 'doppler_std' : __doppler_std, + 'uptime' : __uptime, + 'clock_offset' : __clock_offset, + 'clock_drift' : __clock_drift, + 'corr_spacing' : __corr_spacing, + 'acceleration' : __acceleration, + 'sync_flags' : __sync_flags, + 'tow_flags' : __tow_flags, + 'track_flags' : __track_flags, + 'nav_flags' : __nav_flags, + 'pset_flags' : __pset_flags, + 'misc_flags' : __misc_flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.recv_time = res['recv_time'] + self.tot = res['tot'] + self.P = res['P'] + self.P_std = res['P_std'] + self.L = res['L'] + self.cn0 = res['cn0'] + self.lock = res['lock'] + self.sid = res['sid'] + self.doppler = res['doppler'] + self.doppler_std = res['doppler_std'] + self.uptime = res['uptime'] + self.clock_offset = res['clock_offset'] + self.clock_drift = res['clock_drift'] + self.corr_spacing = res['corr_spacing'] + self.acceleration = res['acceleration'] + self.sync_flags = res['sync_flags'] + self.tow_flags = res['tow_flags'] + self.track_flags = res['track_flags'] + self.nav_flags = res['nav_flags'] + self.pset_flags = res['pset_flags'] + self.misc_flags = res['misc_flags'] + return res, off, length + +SBP_MSG_TRACKING_STATE_DETAILED_DEP = 0x0011 +class MsgTrackingStateDetailedDep(SBP): + """SBP class for message MSG_TRACKING_STATE_DETAILED_DEP (0x0011). + + You can have MSG_TRACKING_STATE_DETAILED_DEP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['recv_time', + 'tot', + 'P', + 'P_std', + 'L', + 'cn0', + 'lock', + 'sid', + 'doppler', + 'doppler_std', + 'uptime', + 'clock_offset', + 'clock_drift', + 'corr_spacing', + 'acceleration', + 'sync_flags', + 'tow_flags', + 'track_flags', + 'nav_flags', + 'pset_flags', + 'misc_flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__recv_time, offset, length) = offset, get_u64(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tot, offset, length) = offset, GPSTimeDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__P, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__P_std, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__L, offset, length) = offset, CarrierPhase.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cn0, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__lock, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__doppler, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__doppler_std, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__uptime, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__clock_offset, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__clock_drift, offset, length) = offset, get_s16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__corr_spacing, offset, length) = offset, get_u16(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__acceleration, offset, length) = offset, get_s8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sync_flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__tow_flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__track_flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__nav_flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__pset_flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__misc_flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'recv_time' : __recv_time, + 'tot' : __tot, + 'P' : __P, + 'P_std' : __P_std, + 'L' : __L, + 'cn0' : __cn0, + 'lock' : __lock, + 'sid' : __sid, + 'doppler' : __doppler, + 'doppler_std' : __doppler_std, + 'uptime' : __uptime, + 'clock_offset' : __clock_offset, + 'clock_drift' : __clock_drift, + 'corr_spacing' : __corr_spacing, + 'acceleration' : __acceleration, + 'sync_flags' : __sync_flags, + 'tow_flags' : __tow_flags, + 'track_flags' : __track_flags, + 'nav_flags' : __nav_flags, + 'pset_flags' : __pset_flags, + 'misc_flags' : __misc_flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.recv_time = res['recv_time'] + self.tot = res['tot'] + self.P = res['P'] + self.P_std = res['P_std'] + self.L = res['L'] + self.cn0 = res['cn0'] + self.lock = res['lock'] + self.sid = res['sid'] + self.doppler = res['doppler'] + self.doppler_std = res['doppler_std'] + self.uptime = res['uptime'] + self.clock_offset = res['clock_offset'] + self.clock_drift = res['clock_drift'] + self.corr_spacing = res['corr_spacing'] + self.acceleration = res['acceleration'] + self.sync_flags = res['sync_flags'] + self.tow_flags = res['tow_flags'] + self.track_flags = res['track_flags'] + self.nav_flags = res['nav_flags'] + self.pset_flags = res['pset_flags'] + self.misc_flags = res['misc_flags'] + return res, off, length + +class TrackingChannelState(object): + """SBP class for message TrackingChannelState + + You can have TrackingChannelState inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Tracking channel state for a specific satellite signal and +measured signal power. + + + """ + __slots__ = ['sid', + 'fcn', + 'cn0', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__fcn, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cn0, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'sid' : __sid, + 'fcn' : __fcn, + 'cn0' : __cn0, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sid = res['sid'] + self.fcn = res['fcn'] + self.cn0 = res['cn0'] + return res, off, length + +SBP_MSG_TRACKING_STATE = 0x0041 +class MsgTrackingState(SBP): + """SBP class for message MSG_TRACKING_STATE (0x0041). + + You can have MSG_TRACKING_STATE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The tracking message returns a variable-length array of tracking +channel states. It reports status and carrier-to-noise density +measurements for all tracked satellites. + + + """ + __slots__ = ['states', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__states, offset, length) = offset, get_array(TrackingChannelState.parse_members)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'states' : __states, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.states = res['states'] + return res, off, length + +class MeasurementState(object): + """SBP class for message MeasurementState + + You can have MeasurementState inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Measurement Engine tracking channel state for a specific satellite signal +and measured signal power. +The mesid field for Glonass can either +carry the FCN as 100 + FCN where FCN is in [-7, +6] or +the Slot ID (from 1 to 28) + + + """ + __slots__ = ['mesid', + 'cn0', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__mesid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cn0, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'mesid' : __mesid, + 'cn0' : __cn0, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.mesid = res['mesid'] + self.cn0 = res['cn0'] + return res, off, length + +SBP_MSG_MEASUREMENT_STATE = 0x0061 +class MsgMeasurementState(SBP): + """SBP class for message MSG_MEASUREMENT_STATE (0x0061). + + You can have MSG_MEASUREMENT_STATE inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The tracking message returns a variable-length array of tracking +channel states. It reports status and carrier-to-noise density +measurements for all tracked satellites. + + + """ + __slots__ = ['states', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__states, offset, length) = offset, get_array(MeasurementState.parse_members)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'states' : __states, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.states = res['states'] + return res, off, length + +class TrackingChannelCorrelation(object): + """SBP class for message TrackingChannelCorrelation + + You can have TrackingChannelCorrelation inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Structure containing in-phase and quadrature correlation components. + + + """ + __slots__ = ['I', + 'Q', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__I, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__Q, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'I' : __I, + 'Q' : __Q, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.I = res['I'] + self.Q = res['Q'] + return res, off, length + +SBP_MSG_TRACKING_IQ = 0x002C +class MsgTrackingIq(SBP): + """SBP class for message MSG_TRACKING_IQ (0x002C). + + You can have MSG_TRACKING_IQ inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + When enabled, a tracking channel can output the correlations at each +update interval. + + + """ + __slots__ = ['channel', + 'sid', + 'corrs', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__channel, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__corrs, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'channel' : __channel, + 'sid' : __sid, + 'corrs' : __corrs, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.channel = res['channel'] + self.sid = res['sid'] + self.corrs = res['corrs'] + return res, off, length + +SBP_MSG_TRACKING_IQ_DEP = 0x001C +class MsgTrackingIqDep(SBP): + """SBP class for message MSG_TRACKING_IQ_DEP (0x001C). + + You can have MSG_TRACKING_IQ_DEP inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['channel', + 'sid', + 'corrs', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__channel, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__corrs, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'channel' : __channel, + 'sid' : __sid, + 'corrs' : __corrs, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.channel = res['channel'] + self.sid = res['sid'] + self.corrs = res['corrs'] + return res, off, length + +class TrackingChannelStateDepA(object): + """SBP class for message TrackingChannelStateDepA + + You can have TrackingChannelStateDepA inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['state', + 'prn', + 'cn0', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__state, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__prn, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cn0, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'state' : __state, + 'prn' : __prn, + 'cn0' : __cn0, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.state = res['state'] + self.prn = res['prn'] + self.cn0 = res['cn0'] + return res, off, length + +SBP_MSG_TRACKING_STATE_DEP_A = 0x0016 +class MsgTrackingStateDepA(SBP): + """SBP class for message MSG_TRACKING_STATE_DEP_A (0x0016). + + You can have MSG_TRACKING_STATE_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['states', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__states, offset, length) = offset, get_array(TrackingChannelStateDepA.parse_members)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'states' : __states, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.states = res['states'] + return res, off, length + +class TrackingChannelStateDepB(object): + """SBP class for message TrackingChannelStateDepB + + You can have TrackingChannelStateDepB inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['state', + 'sid', + 'cn0', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__state, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__cn0, offset, length) = offset, get_f32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'state' : __state, + 'sid' : __sid, + 'cn0' : __cn0, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.state = res['state'] + self.sid = res['sid'] + self.cn0 = res['cn0'] + return res, off, length + +SBP_MSG_TRACKING_STATE_DEP_B = 0x0013 +class MsgTrackingStateDepB(SBP): + """SBP class for message MSG_TRACKING_STATE_DEP_B (0x0013). + + You can have MSG_TRACKING_STATE_DEP_B inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + """ + __slots__ = ['states', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__states, offset, length) = offset, get_array(TrackingChannelStateDepB.parse_members)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'states' : __states, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.states = res['states'] + return res, off, length + + +msg_classes = { + 0x0021: MsgTrackingStateDetailedDepA, + 0x0011: MsgTrackingStateDetailedDep, + 0x0041: MsgTrackingState, + 0x0061: MsgMeasurementState, + 0x002C: MsgTrackingIq, + 0x001C: MsgTrackingIqDep, + 0x0016: MsgTrackingStateDepA, + 0x0013: MsgTrackingStateDepB, +} \ No newline at end of file diff --git a/python/sbp/jit/user.py b/python/sbp/jit/user.py new file mode 100644 index 0000000000..f1fdb63ce4 --- /dev/null +++ b/python/sbp/jit/user.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Messages reserved for use by the user. + +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array + +# Automatically generated from piksi/yaml/swiftnav/sbp/user.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_USER_DATA = 0x0800 +class MsgUserData(SBP): + """SBP class for message MSG_USER_DATA (0x0800). + + You can have MSG_USER_DATA inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + This message can contain any application specific user data up to a +maximum length of 255 bytes per message. + + + """ + __slots__ = ['contents', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__contents, offset, length) = offset, get_array(get_u8)(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'contents' : __contents, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.contents = res['contents'] + return res, off, length + + +msg_classes = { + 0x0800: MsgUserData, +} \ No newline at end of file diff --git a/python/sbp/jit/vehicle.py b/python/sbp/jit/vehicle.py new file mode 100644 index 0000000000..1b2bd6c4f3 --- /dev/null +++ b/python/sbp/jit/vehicle.py @@ -0,0 +1,79 @@ +#!/usr/bin/env python +# Copyright (C) 2015-2018 Swift Navigation Inc. +# Contact: Swift Navigation +# +# This source is subject to the license found in the file 'LICENSE' which must +# be be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + + +""" +Messages from a vehicle. +""" + +import json + +from sbp.jit.msg import SBP, SENDER_ID +from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 +from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 +from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_array, get_fixed_array + +# Automatically generated from piksi/yaml/swiftnav/sbp/vehicle.yaml with generate.py. +# Please do not hand edit! +SBP_MSG_ODOMETRY = 0x0903 +class MsgOdometry(SBP): + """SBP class for message MSG_ODOMETRY (0x0903). + + You can have MSG_ODOMETRY inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Message representing the x component of vehicle velocity in the user frame at the odometry +reference point(s) specified by the user. The offset for the odometry reference point and +the definition and origin of the user frame are defined through the device settings interface. +There are 4 possible user-defined sources of this message which are labeled arbitrarily +source 0 through 3. + + + """ + __slots__ = ['tow', + 'velocity', + 'flags', + ] + @classmethod + def parse_members(cls, buf, offset, length): + o_0 = offset + o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__velocity, offset, length) = offset, get_s32(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) + if o_1 == offset: + return {}, o_0, length + return { + 'tow' : __tow, + 'velocity' : __velocity, + 'flags' : __flags, + }, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.tow = res['tow'] + self.velocity = res['velocity'] + self.flags = res['flags'] + return res, off, length + + +msg_classes = { + 0x0903: MsgOdometry, +} \ No newline at end of file From d6e7d081e6d0723c95e4e6c96651b95cb3d0b1fd Mon Sep 17 00:00:00 2001 From: Jason Mobarak Date: Tue, 26 Feb 2019 20:20:45 -0800 Subject: [PATCH 07/30] Add module for parsing packed float values --- python/sbp/jit/parse_float.py | 37 +++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 python/sbp/jit/parse_float.py diff --git a/python/sbp/jit/parse_float.py b/python/sbp/jit/parse_float.py new file mode 100644 index 0000000000..b5e329ee15 --- /dev/null +++ b/python/sbp/jit/parse_float.py @@ -0,0 +1,37 @@ +import cffi + +ffi = cffi.FFI() +ffi.cdef(""" +float get_f32(unsigned char a, unsigned char b, unsigned char c, unsigned char d); +float get_f64(unsigned char a, unsigned char b, unsigned char c, unsigned char d, + unsigned char e, unsigned char f, unsigned char g, unsigned char h); +""") + +source = """ +float get_f32(unsigned char a, unsigned char b, unsigned char c, unsigned char d) { + union { unsigned char buf[4]; float f; } u; + u.buf[0] = a; + u.buf[1] = b; + u.buf[2] = c; + u.buf[3] = d; + return u.f; +} + +float get_f64(unsigned char a, unsigned char b, unsigned char c, unsigned char d, + unsigned char e, unsigned char f, unsigned char g, unsigned char h) { + union { unsigned char buf[8]; double d; } u; + u.buf[0] = a; + u.buf[1] = b; + u.buf[2] = c; + u.buf[3] = d; + u.buf[4] = e; + u.buf[5] = f; + u.buf[6] = g; + u.buf[7] = h; + return u.d; +} +""" + +ffi.set_source(module_name="parse_float_c", source=source) + +ffi.compile() From cd831f4a2982fafb8b023ffaa10f7b9acd59483f Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Wed, 3 Apr 2019 12:00:36 +0300 Subject: [PATCH 08/30] Fix get_f64() return value type float to double --- python/sbp/jit/parse_float.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/python/sbp/jit/parse_float.py b/python/sbp/jit/parse_float.py index b5e329ee15..93e9ddfa8b 100644 --- a/python/sbp/jit/parse_float.py +++ b/python/sbp/jit/parse_float.py @@ -3,8 +3,8 @@ ffi = cffi.FFI() ffi.cdef(""" float get_f32(unsigned char a, unsigned char b, unsigned char c, unsigned char d); -float get_f64(unsigned char a, unsigned char b, unsigned char c, unsigned char d, - unsigned char e, unsigned char f, unsigned char g, unsigned char h); +double get_f64(unsigned char a, unsigned char b, unsigned char c, unsigned char d, + unsigned char e, unsigned char f, unsigned char g, unsigned char h); """) source = """ @@ -17,8 +17,8 @@ return u.f; } -float get_f64(unsigned char a, unsigned char b, unsigned char c, unsigned char d, - unsigned char e, unsigned char f, unsigned char g, unsigned char h) { +double get_f64(unsigned char a, unsigned char b, unsigned char c, unsigned char d, + unsigned char e, unsigned char f, unsigned char g, unsigned char h) { union { unsigned char buf[8]; double d; } u; u.buf[0] = a; u.buf[1] = b; From e9a289b417ba6c59dd8ec6752e28a381210333d5 Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Mon, 25 Mar 2019 15:00:07 +0200 Subject: [PATCH 09/30] Fix unit tests --- python/sbp/client/framer.py | 2 +- python/sbp/jit/parse_float.py | 14 +++++++++++++- python/tests/sbp/client/test_driver.py | 2 +- python/tests/sbp/test_numba.py | 18 ++++++++---------- python/tox.ini | 4 +++- 5 files changed, 26 insertions(+), 14 deletions(-) diff --git a/python/sbp/client/framer.py b/python/sbp/client/framer.py index 6270a088bb..4d4305f8b4 100644 --- a/python/sbp/client/framer.py +++ b/python/sbp/client/framer.py @@ -115,7 +115,7 @@ def _receive(self): # empty input preamble = self._read(1) if not preamble: - raise StopIteration + return None elif ord(preamble) != SBP_PREAMBLE: if self._verbose: print("Host Side Unhandled byte: 0x%02x" % ord(preamble)) diff --git a/python/sbp/jit/parse_float.py b/python/sbp/jit/parse_float.py index 93e9ddfa8b..c011031265 100644 --- a/python/sbp/jit/parse_float.py +++ b/python/sbp/jit/parse_float.py @@ -1,5 +1,10 @@ import cffi +import glob +import ntpath +import os +import shutil + ffi = cffi.FFI() ffi.cdef(""" float get_f32(unsigned char a, unsigned char b, unsigned char c, unsigned char d); @@ -32,6 +37,13 @@ } """ -ffi.set_source(module_name="parse_float_c", source=source) +module_name = "parse_float_c" + +ffi.set_source(module_name=module_name, source=source) ffi.compile() + +# Move deliverables to same dir as the script +dest_dir = os.path.dirname(os.path.realpath(__file__)) +for f in glob.glob(os.path.join(os.getcwd(), module_name + '.*')): + shutil.move(f, os.path.join(dest_dir, ntpath.basename(f))) diff --git a/python/tests/sbp/client/test_driver.py b/python/tests/sbp/client/test_driver.py index 7c4f269fd1..e596506f1e 100755 --- a/python/tests/sbp/client/test_driver.py +++ b/python/tests/sbp/client/test_driver.py @@ -43,7 +43,7 @@ def test_tcp_logger(): baud = 115200 t0 = time.time() sleep = 0.1 - timeout = 1.0 + timeout = 5.0 cb_context = {'assert_logger_called': False} def assert_logger(s, **metadata): cb_context['assert_logger_called'] = True diff --git a/python/tests/sbp/test_numba.py b/python/tests/sbp/test_numba.py index fc5dbafb6f..318150e644 100644 --- a/python/tests/sbp/test_numba.py +++ b/python/tests/sbp/test_numba.py @@ -2,7 +2,6 @@ import numpy as np from sbp.file_io import MsgFileioWriteReq -from sbp.jit.file_io import MsgFileioWriteReq as MsgFileioWriteReq_j from sbp.jit.msg import SBP @@ -13,7 +12,7 @@ def _mk_string(val, null='\x00'): - ba = bytearray(val + (null if null is not None else '')) + ba = bytearray(val + (null if null is not None else ''), 'ascii') return np.array(ba, dtype=np.uint8) @@ -21,35 +20,35 @@ def test_get_string(): s = _mk_string('thisisastring') out, offset, length = get_string(s, 0, len(s)) assert len(out) == len('thisisastring') - assert out == 'thisisastring' + assert out == b'thisisastring' def test_get_string_no_null(): s = _mk_string('thisisastring', null=None) out, offset, length = get_string(s, 0, len(s)) assert len(out) == len('thisisastring') - assert out == 'thisisastring' + assert out == b'thisisastring' def test_get_string_offset_no_null(): s = _mk_string('________thisisastring', null=None) out, offset, length = get_string(s, 8, len(s) - 8) assert len(out) == len('thisisastring') - assert out == 'thisisastring' + assert out == b'thisisastring' def test_get_string_offset(): s = _mk_string('________thisisastring') out, offset, length = get_string(s, 8, len(s)) assert len(out) == len('thisisastring') - assert out == 'thisisastring' + assert out == b'thisisastring' def test_get_fixed_string_offset(): s = _mk_string('________thisisastring') out, offset, length = get_fixed_string(6)(s, 8, len(s)) assert len(out) == len('thisis') - assert out == 'thisis' + assert out == b'thisis' def test_parse(): @@ -63,10 +62,9 @@ def test_parse(): filename=b'floof.bin\0' + data, data=b'') - buf = m.to_binary() - b = buf.tobytes() + buf = np.fromstring(m.to_binary(), dtype=np.uint8) - assert b != b'' + assert len(buf) > 0 pkt_len, payload_len, msg_type, sender, crc, crc_fail = SBP.unpack_payload(buf, 0, len(buf)) assert not crc_fail diff --git a/python/tox.ini b/python/tox.ini index 1b9e608f17..189ae48416 100644 --- a/python/tox.ini +++ b/python/tox.ini @@ -5,5 +5,7 @@ minversion = 1.7.2 [testenv] deps = -r{toxinidir}/requirements.txt -r{toxinidir}/test_requirements.txt -commands = py.test -v tests/ {posargs} +commands = + python {toxinidir}/sbp/jit/parse_float.py + py.test -v tests/ {posargs} sitepackages = False From d47e75b935356df7ac8b27b287d863b3d83be0b0 Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Thu, 4 Apr 2019 13:16:24 +0300 Subject: [PATCH 10/30] Use standard_b64encode() to omit newlines --- python/sbp/jit/msg.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/sbp/jit/msg.py b/python/sbp/jit/msg.py index d5be94b54c..bea3a2365f 100644 --- a/python/sbp/jit/msg.py +++ b/python/sbp/jit/msg.py @@ -287,7 +287,7 @@ def unpack(self, payload, offset, length): return res, offset, length res['msg_type'] = self.msg_type if self.payload is not None: - res['payload'] = pybase64.encodebytes(self.payload.tobytes()) + res['payload'] = pybase64.standard_b64encode(self.payload.tobytes()) res['crc'] = self.crc res['length'] = self.length return res, offset, length From 25cd75d7ae098d2500a78d5b5d75433c67e2fd9c Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Thu, 4 Apr 2019 13:26:16 +0300 Subject: [PATCH 11/30] payload as str as in the original msg.py --- python/sbp/jit/msg.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/python/sbp/jit/msg.py b/python/sbp/jit/msg.py index bea3a2365f..0f77a9616a 100644 --- a/python/sbp/jit/msg.py +++ b/python/sbp/jit/msg.py @@ -10,7 +10,7 @@ # EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED # WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. -import pybase64 +from pybase64 import standard_b64encode import numpy as np import numba as nb @@ -278,7 +278,7 @@ def parse_members(cls, buf, offset, length): raise NotImplementedError() def _unpack_members(self, buf, offset, length): - raise NotImplementedError() + raise NotImplementedError(self.msg_type) def unpack(self, payload, offset, length): # res, offset, length = {}, offset+length, 0 @@ -287,7 +287,7 @@ def unpack(self, payload, offset, length): return res, offset, length res['msg_type'] = self.msg_type if self.payload is not None: - res['payload'] = pybase64.standard_b64encode(self.payload.tobytes()) + res['payload'] = standard_b64encode(self.payload.tobytes()).decode('ascii') res['crc'] = self.crc res['length'] = self.length return res, offset, length From 3b305d7d6f1b71fb5ef96b7258a04a32de41a536 Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Thu, 4 Apr 2019 13:43:03 +0300 Subject: [PATCH 12/30] Add preamble and sender elements --- python/sbp/jit/msg.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/python/sbp/jit/msg.py b/python/sbp/jit/msg.py index 0f77a9616a..28531d8f4d 100644 --- a/python/sbp/jit/msg.py +++ b/python/sbp/jit/msg.py @@ -19,6 +19,7 @@ from sbp.msg import crc16jit from sbp.msg import SENDER_ID as _SENDER_ID +from sbp.msg import SBP_PREAMBLE as _SBP_PREAMBLE from sbp.jit import parse_float_c @@ -29,6 +30,7 @@ _get_f64 = parse_float_c.lib.get_f64 SENDER_ID = _SENDER_ID +SBP_PREAMBLE = _SBP_PREAMBLE @nb.jit('Tuple((u1,u4,u4))(u1[:],u4,u4)', nopython=True, nogil=True) @@ -217,6 +219,7 @@ def __init__(self, length=None, payload=None, crc=None): + self.preamble = SBP_PREAMBLE self.msg_type = msg_type self.sender = sender self.length = length @@ -283,9 +286,13 @@ def _unpack_members(self, buf, offset, length): def unpack(self, payload, offset, length): # res, offset, length = {}, offset+length, 0 res, offset, length = self._unpack_members(payload, offset, length) + if not res: return res, offset, length + + res['preamble'] = self.preamble res['msg_type'] = self.msg_type + res['sender'] = self.sender if self.payload is not None: res['payload'] = standard_b64encode(self.payload.tobytes()).decode('ascii') res['crc'] = self.crc From 6705f7822d787db2a0aa759c4c3c65fabb757122 Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Thu, 4 Apr 2019 14:14:06 +0300 Subject: [PATCH 13/30] Disregard null incase of get_fixed_string() --- python/sbp/jit/msg.py | 10 +++++----- python/tests/sbp/test_numba.py | 8 ++++++++ 2 files changed, 13 insertions(+), 5 deletions(-) diff --git a/python/sbp/jit/msg.py b/python/sbp/jit/msg.py index 28531d8f4d..2b06f4bf13 100644 --- a/python/sbp/jit/msg.py +++ b/python/sbp/jit/msg.py @@ -143,13 +143,13 @@ def get_f64(buf, offset, length): return res, offset + 8, length - 8 -@nb.jit('Tuple((u1[:],u4,u4))(u1[:],u4,u4)', nopython=True, nogil=True) -def _get_string(buf_in, offset, length): +@nb.jit('Tuple((u1[:],u4,u4))(u1[:],u4,u4,b1)', nopython=True, nogil=True) +def _get_string(buf_in, offset, length, check_null): buf_out = np.zeros(256, dtype=np.uint8) i = nb.u4(0) null_term = False while i < length: - if buf_in[offset + i] == 0: + if check_null and buf_in[offset + i] == 0: null_term = True break buf_out[i] = buf_in[offset + i] @@ -161,7 +161,7 @@ def _get_string(buf_in, offset, length): def get_string(buf, offset, length): - buf, offset, length = _get_string(buf, offset, length) + buf, offset, length = _get_string(buf, offset, length, True) return buf.tobytes(), offset, length @@ -169,7 +169,7 @@ def get_fixed_string(size): def func(buf, offset_in, length): if length < size: return '', offset_in, length - buf, offset, length = _get_string(buf, offset_in, size) + buf, offset, length = _get_string(buf, offset_in, size, False) return buf.tobytes(), offset_in + size, length return func diff --git a/python/tests/sbp/test_numba.py b/python/tests/sbp/test_numba.py index 318150e644..092e7cb9bf 100644 --- a/python/tests/sbp/test_numba.py +++ b/python/tests/sbp/test_numba.py @@ -44,6 +44,14 @@ def test_get_string_offset(): assert out == b'thisisastring' +def test_get_fixed_string(): + s = b'main\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + a = np.fromstring(s, dtype=np.uint8) + out, offset, length = get_fixed_string(len(s))(a, 0, len(a)) + assert len(out) == len(s) + assert out == s + + def test_get_fixed_string_offset(): s = _mk_string('________thisisastring') out, offset, length = get_fixed_string(6)(s, 8, len(s)) From 10991cbb5d378f53ca1082888c2f4cb61786cb3a Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Thu, 4 Apr 2019 16:21:50 +0300 Subject: [PATCH 14/30] Retain float precision metadata --- generator/sbpg/targets/pythonNG.py | 6 +++++- generator/sbpg/targets/resources/sbp_numba.py.j2 | 4 +++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/generator/sbpg/targets/pythonNG.py b/generator/sbpg/targets/pythonNG.py index 36e21dac01..fbd83b9337 100755 --- a/generator/sbpg/targets/pythonNG.py +++ b/generator/sbpg/targets/pythonNG.py @@ -80,7 +80,10 @@ def is_array(): def numba_type(f): - return NUMBA_TYPE[f] + if f.type_id == 'float' or f.type_id == 'double': + return 'nb.' + NUMBA_TYPE[f.type_id] + '(__' + f.identifier + ')' + else: + return '__' + f.identifier def numba_format(f): @@ -124,6 +127,7 @@ def classnameify(s): JENV.filters['numba_py'] = numba_format +JENV.filters['numba_type'] = numba_type JENV.filters['classnameify'] = classnameify JENV.filters['pydoc'] = pydoc_format JENV.filters['comment_links'] = comment_links diff --git a/generator/sbpg/targets/resources/sbp_numba.py.j2 b/generator/sbpg/targets/resources/sbp_numba.py.j2 index c186945e48..5de46ef6e1 100755 --- a/generator/sbpg/targets/resources/sbp_numba.py.j2 +++ b/generator/sbpg/targets/resources/sbp_numba.py.j2 @@ -16,6 +16,8 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 @@ -72,7 +74,7 @@ class ((( m.identifier )))(object): ((*- endfor *)) return { ((*- for f in m.fields *)) - '(((f.identifier)))' : __(((f.identifier))), + '(((f.identifier)))' : ((( f | numba_type ))), ((*- endfor *)) }, offset, length From fb8c06a291315be23185ec5bfd89c7bf8e80864b Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Fri, 5 Apr 2019 10:20:13 +0300 Subject: [PATCH 15/30] Handle setting string NULL delimiters --- generator/sbpg/targets/pythonNG.py | 3 +++ generator/sbpg/targets/resources/sbp_numba.py.j2 | 2 +- python/sbp/jit/msg.py | 5 +++++ 3 files changed, 9 insertions(+), 1 deletion(-) diff --git a/generator/sbpg/targets/pythonNG.py b/generator/sbpg/targets/pythonNG.py index fbd83b9337..97b004c3ac 100755 --- a/generator/sbpg/targets/pythonNG.py +++ b/generator/sbpg/targets/pythonNG.py @@ -89,6 +89,9 @@ def numba_type(f): def numba_format(f): if NUMBA_GET_FN.get(f.type_id, None): return NUMBA_GET_FN.get(f.type_id) + elif f.type_id == 'string' and f.identifier == 'setting' and not f.options.get('size', None): + # setting string with null delimiters as a special case + return 'get_setting' elif f.type_id == 'string' and f.options.get('size', None): s = f.options.get('size', None).value return 'get_fixed_string(%d)' % (s,) diff --git a/generator/sbpg/targets/resources/sbp_numba.py.j2 b/generator/sbpg/targets/resources/sbp_numba.py.j2 index 5de46ef6e1..980a373df1 100755 --- a/generator/sbpg/targets/resources/sbp_numba.py.j2 +++ b/generator/sbpg/targets/resources/sbp_numba.py.j2 @@ -22,7 +22,7 @@ from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array ((*- for i in include *)) diff --git a/python/sbp/jit/msg.py b/python/sbp/jit/msg.py index 2b06f4bf13..380373cad1 100644 --- a/python/sbp/jit/msg.py +++ b/python/sbp/jit/msg.py @@ -174,6 +174,11 @@ def func(buf, offset_in, length): return func +def get_setting(buf, offset, length): + buf, offset, length = _get_string(buf, offset, length, False) + return buf.tobytes(), offset, length + + def get_array(getter): def func(buf, offset, length): arr = [] From 52af16d0a19e91a70d1d6925352c39575e1f0031 Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Fri, 5 Apr 2019 12:36:13 +0300 Subject: [PATCH 16/30] Search for preamble --- python/sbp/jit/msg.py | 26 +++++++++++++++++++++----- 1 file changed, 21 insertions(+), 5 deletions(-) diff --git a/python/sbp/jit/msg.py b/python/sbp/jit/msg.py index 380373cad1..cf4313982c 100644 --- a/python/sbp/jit/msg.py +++ b/python/sbp/jit/msg.py @@ -251,34 +251,50 @@ def __eq__(self, other): def unpack_payload(buf, offset, length): crc_fail = False crc = 0 - pkt_len = 0 payload_len = 0 msg_type = 0 sender = 0 offset_start = offset - header_len = 6 - if length < header_len: + pkt_len = 0 + + preamble_len = 1 + if length < preamble_len: return (pkt_len, payload_len, msg_type, sender, crc, crc_fail) + preamble, offset, length = get_u8(buf, offset, length) + if preamble != SBP_PREAMBLE: + return (preamble_len, payload_len, msg_type, sender, crc, crc_fail) + + header_len = 5 + if length < header_len: + return (pkt_len, payload_len, msg_type, sender, crc, crc_fail) + typ, offset, length = get_u16(buf, offset, length) sender, offset, length = get_u16(buf, offset, length) payload_len, offset, length = get_u8(buf, offset, length) + if length < payload_len: return (pkt_len, payload_len, msg_type, sender, crc, crc_fail) + msg_type = typ + # Consume payload offset += payload_len length -= payload_len + crc_len = 2 if length < crc_len: return (pkt_len, payload_len, msg_type, sender, crc, crc_fail) + crc, offset, length = get_u16(buf, offset, length) buf_start = offset_start + 1 - buf_end = offset_start + 1 + (header_len - 1) + payload_len + buf_end = offset_start + 1 + (preamble_len + header_len - 1) + payload_len + calc_crc = crc16jit(buf, buf_start, 0, buf_end - buf_start) if calc_crc != crc: crc_fail = True - pkt_len = header_len + payload_len + crc_len + + pkt_len = preamble_len + header_len + payload_len + crc_len return (pkt_len, payload_len, msg_type, sender, crc, crc_fail) @classmethod From 4c2b830f81f4db4069ba38a6265469e178fa9159 Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Fri, 5 Apr 2019 15:50:03 +0300 Subject: [PATCH 17/30] Do not return valid msg_type if crc is not in window --- python/sbp/jit/msg.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/python/sbp/jit/msg.py b/python/sbp/jit/msg.py index cf4313982c..a497ad0f84 100644 --- a/python/sbp/jit/msg.py +++ b/python/sbp/jit/msg.py @@ -276,8 +276,6 @@ def unpack_payload(buf, offset, length): if length < payload_len: return (pkt_len, payload_len, msg_type, sender, crc, crc_fail) - msg_type = typ - # Consume payload offset += payload_len length -= payload_len @@ -286,6 +284,8 @@ def unpack_payload(buf, offset, length): if length < crc_len: return (pkt_len, payload_len, msg_type, sender, crc, crc_fail) + msg_type = typ + crc, offset, length = get_u16(buf, offset, length) buf_start = offset_start + 1 buf_end = offset_start + 1 + (preamble_len + header_len - 1) + payload_len From fa61a4062dae3d49179adc87d3ae0f3959509f36 Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Fri, 5 Apr 2019 15:51:27 +0300 Subject: [PATCH 18/30] Implement _unpack_members() for message with no payload --- generator/sbpg/targets/resources/sbp_numba.py.j2 | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/generator/sbpg/targets/resources/sbp_numba.py.j2 b/generator/sbpg/targets/resources/sbp_numba.py.j2 index 980a373df1..1b2bf17603 100755 --- a/generator/sbpg/targets/resources/sbp_numba.py.j2 +++ b/generator/sbpg/targets/resources/sbp_numba.py.j2 @@ -87,8 +87,9 @@ class ((( m.identifier )))(object): ((*- endfor *)) return res, off, length ((* else *)) + def _unpack_members(self, buf, offset, length): + return {}, offset, length ((* endif *)) - ((*- endif *)) ((*- endfor *)) From 99fc0d714b9cb26400d5ab702aef4c110e1a4534 Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Fri, 5 Apr 2019 17:01:12 +0300 Subject: [PATCH 19/30] Streamline parse_members() --- generator/sbpg/targets/resources/sbp_numba.py.j2 | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/generator/sbpg/targets/resources/sbp_numba.py.j2 b/generator/sbpg/targets/resources/sbp_numba.py.j2 index 1b2bf17603..3ef9aea300 100755 --- a/generator/sbpg/targets/resources/sbp_numba.py.j2 +++ b/generator/sbpg/targets/resources/sbp_numba.py.j2 @@ -66,17 +66,12 @@ class ((( m.identifier )))(object): ((*- if m.fields *)) @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset + ret = {} ((*- for f in m.fields *)) - o_1, (__(((f.identifier))), offset, length) = offset, ((( f | numba_py )))(buf, offset, length) - if o_1 == offset: - return {}, o_0, length + (__(((f.identifier))), offset, length) = ((( f | numba_py )))(buf, offset, length) + ret['(((f.identifier)))'] = ((( f | numba_type ))) ((*- endfor *)) - return { - ((*- for f in m.fields *)) - '(((f.identifier)))' : ((( f | numba_type ))), - ((*- endfor *)) - }, offset, length + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) From c69aea296e7b6d3f626bf29223f9bcd7c8005df5 Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Fri, 5 Apr 2019 17:03:30 +0300 Subject: [PATCH 20/30] Fix get_fixed_array() --- python/sbp/jit/msg.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/python/sbp/jit/msg.py b/python/sbp/jit/msg.py index a497ad0f84..6ad0463437 100644 --- a/python/sbp/jit/msg.py +++ b/python/sbp/jit/msg.py @@ -181,6 +181,7 @@ def get_setting(buf, offset, length): def get_array(getter): def func(buf, offset, length): + # TODO verify this function arr = [] while length > 0: o_1, (res, offset, length) = offset, getter(buf, offset, length) @@ -196,15 +197,15 @@ def func(buf, offset, length): offset_start = offset total_size = count * el_size if length < total_size: - return [], offset_start, 0 + return [], offset_start, length arr = [] - while length > 0: + while total_size > 0: o_1, (res, offset, length) = offset, getter(buf, offset, length) if o_1 == offset: - return [], offset_start, 0 + return [], offset_start, length arr.append(res) - length -= el_size - return arr, offset, length-total_size + total_size -= el_size + return arr, offset, length return func From ebb39455533e1ed1ac47fc1e232d87a818d14334 Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Tue, 9 Apr 2019 15:06:22 +0300 Subject: [PATCH 21/30] Use correct getter in get_fixed_array --- generator/sbpg/targets/pythonNG.py | 29 +++++++++++++++---- .../sbpg/targets/resources/sbp_numba.py.j2 | 10 +++++++ 2 files changed, 33 insertions(+), 6 deletions(-) diff --git a/generator/sbpg/targets/pythonNG.py b/generator/sbpg/targets/pythonNG.py index 97b004c3ac..013589e322 100755 --- a/generator/sbpg/targets/pythonNG.py +++ b/generator/sbpg/targets/pythonNG.py @@ -86,6 +86,13 @@ def numba_type(f): return '__' + f.identifier +def numba_size(f): + if f.type_id in NUMBA_TY_BYTES: + return NUMBA_TY_BYTES[f.type_id] + else: + return f.identifier + '._payload_size()' + + def numba_format(f): if NUMBA_GET_FN.get(f.type_id, None): return NUMBA_GET_FN.get(f.type_id) @@ -99,12 +106,21 @@ def numba_format(f): return 'get_string' elif f.type_id == 'array' and f.options.get('size', None): count = f.options.get('size', None).value - t = NUMBA_GET_FN.get(f.type_id, 'u8') - if t not in NUMBA_GET_FN: - raise NotImplementedError() - fill_func = NUMBA_GET_FN[t] - el_size = NUMBA_TY_BYTES[t] - return "get_fixed_array(%s, %d, %d)" % (fill_func, count, el_size) + t = f.options['fill'].value + if t in NUMBA_GET_FN: + fill_func = NUMBA_GET_FN[t] + el_size = NUMBA_TY_BYTES[t] + # TODO clean.. + if f.options['fill'].value == 'float': + return "get_fixed_array(%s, %d, %d, %s)" % (fill_func, count, el_size, 'nb.f4') + elif f.options['fill'].value == 'double': + return "get_fixed_array(%s, %d, %d, %s)" % (fill_func, count, el_size, 'nb.f8') + else: + return "get_fixed_array(%s, %d, %d)" % (fill_func, count, el_size) + else: + fill_func = f.options['fill'].value + '._unpack_members' + el_size = f.options['fill'].value + '._payload_size()' + return "get_fixed_array(%s, %d, %s)" % (fill_func, count, el_size) elif f.type_id == 'array': fill = f.options['fill'].value f_ = copy.copy(f) @@ -131,6 +147,7 @@ def classnameify(s): JENV.filters['numba_py'] = numba_format JENV.filters['numba_type'] = numba_type +JENV.filters['numba_size'] = numba_size JENV.filters['classnameify'] = classnameify JENV.filters['pydoc'] = pydoc_format JENV.filters['comment_links'] = comment_links diff --git a/generator/sbpg/targets/resources/sbp_numba.py.j2 b/generator/sbpg/targets/resources/sbp_numba.py.j2 index 3ef9aea300..027a5c335b 100755 --- a/generator/sbpg/targets/resources/sbp_numba.py.j2 +++ b/generator/sbpg/targets/resources/sbp_numba.py.j2 @@ -81,9 +81,19 @@ class ((( m.identifier )))(object): self.(((f.identifier))) = res['(((f.identifier)))'] ((*- endfor *)) return res, off, length + + def _payload_size(self): + ret = 0 + ((*- for f in m.fields *)) + ret += (((f | numba_size))) + ((*- endfor *)) + return ret ((* else *)) def _unpack_members(self, buf, offset, length): return {}, offset, length + + def _payload_size(self): + return 0 ((* endif *)) ((*- endif *)) ((*- endfor *)) From c1545e7fa002c5904e8d83dfa8dab0e8610facf4 Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Tue, 9 Apr 2019 15:06:50 +0300 Subject: [PATCH 22/30] Add payload size metadata --- python/sbp/jit/msg.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/python/sbp/jit/msg.py b/python/sbp/jit/msg.py index 6ad0463437..ed57a20f2c 100644 --- a/python/sbp/jit/msg.py +++ b/python/sbp/jit/msg.py @@ -192,7 +192,7 @@ def func(buf, offset, length): return func -def get_fixed_array(getter, count, el_size): +def get_fixed_array(getter, count, el_size, nb_type=None): def func(buf, offset, length): offset_start = offset total_size = count * el_size @@ -203,7 +203,7 @@ def func(buf, offset, length): o_1, (res, offset, length) = offset, getter(buf, offset, length) if o_1 == offset: return [], offset_start, length - arr.append(res) + arr.append(nb_type(res) if nb_type else res) total_size -= el_size return arr, offset, length return func From 0425fb132688d2d6f6fcc13ef0183d7b6fed3c4c Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Wed, 10 Apr 2019 12:17:01 +0300 Subject: [PATCH 23/30] Do not discriminate messages with no payload --- python/sbp/jit/msg.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/python/sbp/jit/msg.py b/python/sbp/jit/msg.py index ed57a20f2c..ff3d35d67e 100644 --- a/python/sbp/jit/msg.py +++ b/python/sbp/jit/msg.py @@ -306,12 +306,8 @@ def _unpack_members(self, buf, offset, length): raise NotImplementedError(self.msg_type) def unpack(self, payload, offset, length): - # res, offset, length = {}, offset+length, 0 res, offset, length = self._unpack_members(payload, offset, length) - if not res: - return res, offset, length - res['preamble'] = self.preamble res['msg_type'] = self.msg_type res['sender'] = self.sender From ff73ab42c532773e33bd7e812244fa6ff032a9b3 Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Wed, 10 Apr 2019 12:53:59 +0300 Subject: [PATCH 24/30] Payload size fixes --- generator/sbpg/targets/pythonNG.py | 20 ++++++++++++++++++- .../sbpg/targets/resources/sbp_numba.py.j2 | 1 + 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/generator/sbpg/targets/pythonNG.py b/generator/sbpg/targets/pythonNG.py index 013589e322..d7ae4d1220 100755 --- a/generator/sbpg/targets/pythonNG.py +++ b/generator/sbpg/targets/pythonNG.py @@ -87,10 +87,28 @@ def numba_type(f): def numba_size(f): + # the worst case 255 - 6 (header) - 2 (crc) + UNKNOWN_LEN = 255 - 6 - 2 + if f.type_id in NUMBA_TY_BYTES: return NUMBA_TY_BYTES[f.type_id] + elif f.type_id == 'string': + if f.options.get('size', None) is not None: + return f.options.get('size', None).value + return UNKNOWN_LEN + elif f.type_id == 'array': + # NOTE: arrays of arrays are not supported + t = f.options['fill'].value + count = f.options.get('size', None) + if count: + if t in NUMBA_TY_BYTES: + return "%d * %d" % (NUMBA_TY_BYTES[t], count.value) + else: + return t + "._payload_size() * %d" % (count.value) + else: + return UNKNOWN_LEN else: - return f.identifier + '._payload_size()' + return f.type_id + '._payload_size()' def numba_format(f): diff --git a/generator/sbpg/targets/resources/sbp_numba.py.j2 b/generator/sbpg/targets/resources/sbp_numba.py.j2 index 027a5c335b..a47cdc3273 100755 --- a/generator/sbpg/targets/resources/sbp_numba.py.j2 +++ b/generator/sbpg/targets/resources/sbp_numba.py.j2 @@ -82,6 +82,7 @@ class ((( m.identifier )))(object): ((*- endfor *)) return res, off, length + @classmethod def _payload_size(self): ret = 0 ((*- for f in m.fields *)) From 340537441ac5891c31adfb97638af0c06944d9bd Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Wed, 10 Apr 2019 13:05:44 +0300 Subject: [PATCH 25/30] Add comments to _payload_size() --- generator/sbpg/targets/resources/sbp_numba.py.j2 | 1 + 1 file changed, 1 insertion(+) diff --git a/generator/sbpg/targets/resources/sbp_numba.py.j2 b/generator/sbpg/targets/resources/sbp_numba.py.j2 index a47cdc3273..522e0b8277 100755 --- a/generator/sbpg/targets/resources/sbp_numba.py.j2 +++ b/generator/sbpg/targets/resources/sbp_numba.py.j2 @@ -86,6 +86,7 @@ class ((( m.identifier )))(object): def _payload_size(self): ret = 0 ((*- for f in m.fields *)) + # (((f.identifier))): (((f.type_id))) ((*- if f.options['fill'] *)) of (((f.options['fill'].value))) ((*- endif *)) ret += (((f | numba_size))) ((*- endfor *)) return ret From 6a9ae2691fcc220f3514e8517dd829f3f4a03d4e Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Wed, 10 Apr 2019 13:29:17 +0300 Subject: [PATCH 26/30] Decode bytes to strings --- python/sbp/jit/msg.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/python/sbp/jit/msg.py b/python/sbp/jit/msg.py index ff3d35d67e..98522409e7 100644 --- a/python/sbp/jit/msg.py +++ b/python/sbp/jit/msg.py @@ -162,7 +162,7 @@ def _get_string(buf_in, offset, length, check_null): def get_string(buf, offset, length): buf, offset, length = _get_string(buf, offset, length, True) - return buf.tobytes(), offset, length + return buf.tobytes().decode('ascii'), offset, length def get_fixed_string(size): @@ -170,13 +170,13 @@ def func(buf, offset_in, length): if length < size: return '', offset_in, length buf, offset, length = _get_string(buf, offset_in, size, False) - return buf.tobytes(), offset_in + size, length + return buf.tobytes().decode('ascii'), offset_in + size, length return func def get_setting(buf, offset, length): buf, offset, length = _get_string(buf, offset, length, False) - return buf.tobytes(), offset, length + return buf.tobytes().decode('ascii'), offset, length def get_array(getter): From ed4b3f6c3afd8a8462ca81a22e0501dbd7011fe0 Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Wed, 10 Apr 2019 15:25:22 +0300 Subject: [PATCH 27/30] Add class variable switch for floating point meta --- generator/sbpg/targets/pythonNG.py | 6 +++--- python/sbp/jit/msg.py | 5 +++++ 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/generator/sbpg/targets/pythonNG.py b/generator/sbpg/targets/pythonNG.py index d7ae4d1220..bacff3f7fd 100755 --- a/generator/sbpg/targets/pythonNG.py +++ b/generator/sbpg/targets/pythonNG.py @@ -81,7 +81,7 @@ def is_array(): def numba_type(f): if f.type_id == 'float' or f.type_id == 'double': - return 'nb.' + NUMBA_TYPE[f.type_id] + '(__' + f.identifier + ')' + return 'nb.' + NUMBA_TYPE[f.type_id] + '(__' + f.identifier + ') if SBP.float_meta else __' + f.identifier else: return '__' + f.identifier @@ -130,9 +130,9 @@ def numba_format(f): el_size = NUMBA_TY_BYTES[t] # TODO clean.. if f.options['fill'].value == 'float': - return "get_fixed_array(%s, %d, %d, %s)" % (fill_func, count, el_size, 'nb.f4') + return "get_fixed_array(%s, %d, %d, %s if SBP.float_meta else None)" % (fill_func, count, el_size, 'nb.f4') elif f.options['fill'].value == 'double': - return "get_fixed_array(%s, %d, %d, %s)" % (fill_func, count, el_size, 'nb.f8') + return "get_fixed_array(%s, %d, %d, %s if SBP.float_meta else None)" % (fill_func, count, el_size, 'nb.f8') else: return "get_fixed_array(%s, %d, %d)" % (fill_func, count, el_size) else: diff --git a/python/sbp/jit/msg.py b/python/sbp/jit/msg.py index 98522409e7..880fda6b54 100644 --- a/python/sbp/jit/msg.py +++ b/python/sbp/jit/msg.py @@ -212,6 +212,11 @@ def func(buf, offset, length): class SBP(object): """Swift Binary Protocol container. """ + # Class variable for controlling whether floating point variables should be + # stored in numba.float32/64 format or native Python float. This affects + # the rounding and string representation. + float_meta = False + __slots__ = ['preamble', 'msg_type', 'sender', From 1a7848193f3cf995203f11423cb126a2c75768e7 Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Wed, 10 Apr 2019 16:01:38 +0300 Subject: [PATCH 28/30] Fix unit tests for strings --- python/tests/sbp/test_numba.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/python/tests/sbp/test_numba.py b/python/tests/sbp/test_numba.py index 092e7cb9bf..ab2ba285c1 100644 --- a/python/tests/sbp/test_numba.py +++ b/python/tests/sbp/test_numba.py @@ -20,32 +20,32 @@ def test_get_string(): s = _mk_string('thisisastring') out, offset, length = get_string(s, 0, len(s)) assert len(out) == len('thisisastring') - assert out == b'thisisastring' + assert out == 'thisisastring' def test_get_string_no_null(): s = _mk_string('thisisastring', null=None) out, offset, length = get_string(s, 0, len(s)) assert len(out) == len('thisisastring') - assert out == b'thisisastring' + assert out == 'thisisastring' def test_get_string_offset_no_null(): s = _mk_string('________thisisastring', null=None) out, offset, length = get_string(s, 8, len(s) - 8) assert len(out) == len('thisisastring') - assert out == b'thisisastring' + assert out == 'thisisastring' def test_get_string_offset(): s = _mk_string('________thisisastring') out, offset, length = get_string(s, 8, len(s)) assert len(out) == len('thisisastring') - assert out == b'thisisastring' + assert out == 'thisisastring' def test_get_fixed_string(): - s = b'main\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + s = 'main\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' a = np.fromstring(s, dtype=np.uint8) out, offset, length = get_fixed_string(len(s))(a, 0, len(a)) assert len(out) == len(s) @@ -56,7 +56,7 @@ def test_get_fixed_string_offset(): s = _mk_string('________thisisastring') out, offset, length = get_fixed_string(6)(s, 8, len(s)) assert len(out) == len('thisis') - assert out == b'thisis' + assert out == 'thisis' def test_parse(): @@ -84,7 +84,7 @@ def test_parse(): assert res['sequence'] == 123 assert res['offset'] == 42 - assert res['filename'] == b'floof.bin' + assert res['filename'] == 'floof.bin' assert bytearray(res['data']) == bytearray(data) From be5c9915c5d532f5bf6fa78e011b13accd94195e Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Wed, 17 Apr 2019 11:19:06 +0300 Subject: [PATCH 29/30] Do not output numba types --- generator/sbpg/targets/pythonNG.py | 11 ++++---- .../sbpg/targets/resources/sbp_numba.py.j2 | 2 +- python/sbp/jit/msg.py | 28 +++++++++++++++---- 3 files changed, 29 insertions(+), 12 deletions(-) diff --git a/generator/sbpg/targets/pythonNG.py b/generator/sbpg/targets/pythonNG.py index bacff3f7fd..a6730c03ae 100755 --- a/generator/sbpg/targets/pythonNG.py +++ b/generator/sbpg/targets/pythonNG.py @@ -80,8 +80,9 @@ def is_array(): def numba_type(f): - if f.type_id == 'float' or f.type_id == 'double': - return 'nb.' + NUMBA_TYPE[f.type_id] + '(__' + f.identifier + ') if SBP.float_meta else __' + f.identifier + if f.type_id == 'float': + return 'judicious_round(nb.' + NUMBA_TYPE[f.type_id] + \ + '(__' + f.identifier + ')) if SBP.judicious_rounding else __' + f.identifier else: return '__' + f.identifier @@ -128,11 +129,9 @@ def numba_format(f): if t in NUMBA_GET_FN: fill_func = NUMBA_GET_FN[t] el_size = NUMBA_TY_BYTES[t] - # TODO clean.. if f.options['fill'].value == 'float': - return "get_fixed_array(%s, %d, %d, %s if SBP.float_meta else None)" % (fill_func, count, el_size, 'nb.f4') - elif f.options['fill'].value == 'double': - return "get_fixed_array(%s, %d, %d, %s if SBP.float_meta else None)" % (fill_func, count, el_size, 'nb.f8') + return "get_fixed_array(%s, %d, %d, %s if SBP.judicious_rounding else None)" \ + % (fill_func, count, el_size, 'nb.f4') else: return "get_fixed_array(%s, %d, %d)" % (fill_func, count, el_size) else: diff --git a/generator/sbpg/targets/resources/sbp_numba.py.j2 b/generator/sbpg/targets/resources/sbp_numba.py.j2 index 522e0b8277..c0436a5f9f 100755 --- a/generator/sbpg/targets/resources/sbp_numba.py.j2 +++ b/generator/sbpg/targets/resources/sbp_numba.py.j2 @@ -21,7 +21,7 @@ import numba as nb from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 +from sbp.jit.msg import get_f32, get_f64, judicious_round from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array diff --git a/python/sbp/jit/msg.py b/python/sbp/jit/msg.py index 880fda6b54..722cef0633 100644 --- a/python/sbp/jit/msg.py +++ b/python/sbp/jit/msg.py @@ -12,6 +12,8 @@ from pybase64 import standard_b64encode +import decimal as dec + import numpy as np import numba as nb @@ -160,6 +162,15 @@ def _get_string(buf_in, offset, length, check_null): return buf_out[:i], offset + i, i +def judicious_round(f): + # Let numpy's judicious rounding tell us the amount of digits we + # want as it seems to align with Haskell's output + d = dec.Decimal(np.format_float_positional(f, precision=None, unique=True, trim='0')) + # Round it using correct rounding strategy and return it as native float + # NOTE: Can't this be done already on libsbp side? + return float(round(dec.Decimal(float(f)), abs(d.as_tuple().exponent))) + + def get_string(buf, offset, length): buf, offset, length = _get_string(buf, offset, length, True) return buf.tobytes().decode('ascii'), offset, length @@ -203,7 +214,7 @@ def func(buf, offset, length): o_1, (res, offset, length) = offset, getter(buf, offset, length) if o_1 == offset: return [], offset_start, length - arr.append(nb_type(res) if nb_type else res) + arr.append(judicious_round(nb_type(res)) if nb_type else res) total_size -= el_size return arr, offset, length return func @@ -212,10 +223,17 @@ def func(buf, offset, length): class SBP(object): """Swift Binary Protocol container. """ - # Class variable for controlling whether floating point variables should be - # stored in numba.float32/64 format or native Python float. This affects - # the rounding and string representation. - float_meta = False + # Class variable for controlling the rounding. + # False: Only Python native float context will be used, this is faster + # but does not distuingish 32 and 64 bit floats. In practise this + # means that 32 bit float value reprentations will have higher + # precision than they actually have. + # True: Floating point values are handled internally as numpy.float32 and + # numpy.float64. This is slower but doesn't add arbitrary precision + # to the 32 bit values. In practise only 32 bit values are rounded + # as the effect of rounding 64 bit values is lost immediately when + # stored back to Python native float. + judicious_rounding = False __slots__ = ['preamble', 'msg_type', From 60ee7f4a8cfad1b5218da036110e6afb1649a941 Mon Sep 17 00:00:00 2001 From: Pasi Miettinen Date: Thu, 4 Apr 2019 16:23:12 +0300 Subject: [PATCH 30/30] Add generated sbp.jit classes --- python/sbp/jit/acquisition.py | 422 ++-- python/sbp/jit/bootload.py | 96 +- python/sbp/jit/ext_events.py | 56 +- python/sbp/jit/file_io.py | 272 ++- python/sbp/jit/flash.py | 237 +- python/sbp/jit/gnss.py | 178 +- python/sbp/jit/imu.py | 114 +- python/sbp/jit/linux.py | 406 ++-- python/sbp/jit/logging.py | 84 +- python/sbp/jit/mag.py | 56 +- python/sbp/jit/navigation.py | 1734 +++++++------- python/sbp/jit/ndb.py | 80 +- python/sbp/jit/observation.py | 4250 ++++++++++++++++++--------------- python/sbp/jit/orientation.py | 262 +- python/sbp/jit/piksi.py | 877 ++++--- python/sbp/jit/sbas.py | 48 +- python/sbp/jit/settings.py | 184 +- python/sbp/jit/ssr.py | 458 ++-- python/sbp/jit/system.py | 170 +- python/sbp/jit/tracking.py | 771 +++--- python/sbp/jit/user.py | 24 +- python/sbp/jit/vehicle.py | 40 +- 22 files changed, 5981 insertions(+), 4838 deletions(-) diff --git a/python/sbp/jit/acquisition.py b/python/sbp/jit/acquisition.py index 86f3849449..103e20078b 100644 --- a/python/sbp/jit/acquisition.py +++ b/python/sbp/jit/acquisition.py @@ -16,11 +16,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array from sbp.jit.gnss import * @@ -50,25 +52,16 @@ class MsgAcqResult(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__cn0, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cp, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cf, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'cn0' : __cn0, - 'cp' : __cp, - 'cf' : __cf, - 'sid' : __sid, - }, offset, length + ret = {} + (__cn0, offset, length) = get_f32(buf, offset, length) + ret['cn0'] = judicious_round(nb.f4(__cn0)) if SBP.judicious_rounding else __cn0 + (__cp, offset, length) = get_f32(buf, offset, length) + ret['cp'] = judicious_round(nb.f4(__cp)) if SBP.judicious_rounding else __cp + (__cf, offset, length) = get_f32(buf, offset, length) + ret['cf'] = judicious_round(nb.f4(__cf)) if SBP.judicious_rounding else __cf + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -79,6 +72,19 @@ def _unpack_members(self, buf, offset, length): self.cf = res['cf'] self.sid = res['sid'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # cn0: float + ret += 4 + # cp: float + ret += 4 + # cf: float + ret += 4 + # sid: GnssSignal + ret += GnssSignal._payload_size() + return ret SBP_MSG_ACQ_RESULT_DEP_C = 0x001F class MsgAcqResultDepC(SBP): @@ -99,25 +105,16 @@ class MsgAcqResultDepC(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__cn0, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cp, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cf, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'cn0' : __cn0, - 'cp' : __cp, - 'cf' : __cf, - 'sid' : __sid, - }, offset, length + ret = {} + (__cn0, offset, length) = get_f32(buf, offset, length) + ret['cn0'] = judicious_round(nb.f4(__cn0)) if SBP.judicious_rounding else __cn0 + (__cp, offset, length) = get_f32(buf, offset, length) + ret['cp'] = judicious_round(nb.f4(__cp)) if SBP.judicious_rounding else __cp + (__cf, offset, length) = get_f32(buf, offset, length) + ret['cf'] = judicious_round(nb.f4(__cf)) if SBP.judicious_rounding else __cf + (__sid, offset, length) = GnssSignalDep.parse_members(buf, offset, length) + ret['sid'] = __sid + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -128,6 +125,19 @@ def _unpack_members(self, buf, offset, length): self.cf = res['cf'] self.sid = res['sid'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # cn0: float + ret += 4 + # cp: float + ret += 4 + # cf: float + ret += 4 + # sid: GnssSignalDep + ret += GnssSignalDep._payload_size() + return ret SBP_MSG_ACQ_RESULT_DEP_B = 0x0014 class MsgAcqResultDepB(SBP): @@ -148,25 +158,16 @@ class MsgAcqResultDepB(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__snr, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cp, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cf, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'snr' : __snr, - 'cp' : __cp, - 'cf' : __cf, - 'sid' : __sid, - }, offset, length + ret = {} + (__snr, offset, length) = get_f32(buf, offset, length) + ret['snr'] = judicious_round(nb.f4(__snr)) if SBP.judicious_rounding else __snr + (__cp, offset, length) = get_f32(buf, offset, length) + ret['cp'] = judicious_round(nb.f4(__cp)) if SBP.judicious_rounding else __cp + (__cf, offset, length) = get_f32(buf, offset, length) + ret['cf'] = judicious_round(nb.f4(__cf)) if SBP.judicious_rounding else __cf + (__sid, offset, length) = GnssSignalDep.parse_members(buf, offset, length) + ret['sid'] = __sid + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -177,6 +178,19 @@ def _unpack_members(self, buf, offset, length): self.cf = res['cf'] self.sid = res['sid'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # snr: float + ret += 4 + # cp: float + ret += 4 + # cf: float + ret += 4 + # sid: GnssSignalDep + ret += GnssSignalDep._payload_size() + return ret SBP_MSG_ACQ_RESULT_DEP_A = 0x0015 class MsgAcqResultDepA(SBP): @@ -197,25 +211,16 @@ class MsgAcqResultDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__snr, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cp, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cf, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__prn, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'snr' : __snr, - 'cp' : __cp, - 'cf' : __cf, - 'prn' : __prn, - }, offset, length + ret = {} + (__snr, offset, length) = get_f32(buf, offset, length) + ret['snr'] = judicious_round(nb.f4(__snr)) if SBP.judicious_rounding else __snr + (__cp, offset, length) = get_f32(buf, offset, length) + ret['cp'] = judicious_round(nb.f4(__cp)) if SBP.judicious_rounding else __cp + (__cf, offset, length) = get_f32(buf, offset, length) + ret['cf'] = judicious_round(nb.f4(__cf)) if SBP.judicious_rounding else __cf + (__prn, offset, length) = get_u8(buf, offset, length) + ret['prn'] = __prn + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -226,6 +231,19 @@ def _unpack_members(self, buf, offset, length): self.cf = res['cf'] self.prn = res['prn'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # snr: float + ret += 4 + # cp: float + ret += 4 + # cf: float + ret += 4 + # prn: u8 + ret += 1 + return ret class AcqSvProfile(object): """SBP class for message AcqSvProfile @@ -256,57 +274,32 @@ class AcqSvProfile(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__job_type, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__status, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cn0, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__int_time, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__bin_width, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__timestamp, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__time_spent, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cf_min, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cf_max, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cf, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cp, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'job_type' : __job_type, - 'status' : __status, - 'cn0' : __cn0, - 'int_time' : __int_time, - 'sid' : __sid, - 'bin_width' : __bin_width, - 'timestamp' : __timestamp, - 'time_spent' : __time_spent, - 'cf_min' : __cf_min, - 'cf_max' : __cf_max, - 'cf' : __cf, - 'cp' : __cp, - }, offset, length + ret = {} + (__job_type, offset, length) = get_u8(buf, offset, length) + ret['job_type'] = __job_type + (__status, offset, length) = get_u8(buf, offset, length) + ret['status'] = __status + (__cn0, offset, length) = get_u16(buf, offset, length) + ret['cn0'] = __cn0 + (__int_time, offset, length) = get_u8(buf, offset, length) + ret['int_time'] = __int_time + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + (__bin_width, offset, length) = get_u16(buf, offset, length) + ret['bin_width'] = __bin_width + (__timestamp, offset, length) = get_u32(buf, offset, length) + ret['timestamp'] = __timestamp + (__time_spent, offset, length) = get_u32(buf, offset, length) + ret['time_spent'] = __time_spent + (__cf_min, offset, length) = get_s32(buf, offset, length) + ret['cf_min'] = __cf_min + (__cf_max, offset, length) = get_s32(buf, offset, length) + ret['cf_max'] = __cf_max + (__cf, offset, length) = get_s32(buf, offset, length) + ret['cf'] = __cf + (__cp, offset, length) = get_u32(buf, offset, length) + ret['cp'] = __cp + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -325,6 +318,35 @@ def _unpack_members(self, buf, offset, length): self.cf = res['cf'] self.cp = res['cp'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # job_type: u8 + ret += 1 + # status: u8 + ret += 1 + # cn0: u16 + ret += 2 + # int_time: u8 + ret += 1 + # sid: GnssSignal + ret += GnssSignal._payload_size() + # bin_width: u16 + ret += 2 + # timestamp: u32 + ret += 4 + # time_spent: u32 + ret += 4 + # cf_min: s32 + ret += 4 + # cf_max: s32 + ret += 4 + # cf: s32 + ret += 4 + # cp: u32 + ret += 4 + return ret class AcqSvProfileDep(object): """SBP class for message AcqSvProfileDep @@ -352,57 +374,32 @@ class AcqSvProfileDep(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__job_type, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__status, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cn0, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__int_time, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__bin_width, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__timestamp, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__time_spent, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cf_min, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cf_max, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cf, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cp, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'job_type' : __job_type, - 'status' : __status, - 'cn0' : __cn0, - 'int_time' : __int_time, - 'sid' : __sid, - 'bin_width' : __bin_width, - 'timestamp' : __timestamp, - 'time_spent' : __time_spent, - 'cf_min' : __cf_min, - 'cf_max' : __cf_max, - 'cf' : __cf, - 'cp' : __cp, - }, offset, length + ret = {} + (__job_type, offset, length) = get_u8(buf, offset, length) + ret['job_type'] = __job_type + (__status, offset, length) = get_u8(buf, offset, length) + ret['status'] = __status + (__cn0, offset, length) = get_u16(buf, offset, length) + ret['cn0'] = __cn0 + (__int_time, offset, length) = get_u8(buf, offset, length) + ret['int_time'] = __int_time + (__sid, offset, length) = GnssSignalDep.parse_members(buf, offset, length) + ret['sid'] = __sid + (__bin_width, offset, length) = get_u16(buf, offset, length) + ret['bin_width'] = __bin_width + (__timestamp, offset, length) = get_u32(buf, offset, length) + ret['timestamp'] = __timestamp + (__time_spent, offset, length) = get_u32(buf, offset, length) + ret['time_spent'] = __time_spent + (__cf_min, offset, length) = get_s32(buf, offset, length) + ret['cf_min'] = __cf_min + (__cf_max, offset, length) = get_s32(buf, offset, length) + ret['cf_max'] = __cf_max + (__cf, offset, length) = get_s32(buf, offset, length) + ret['cf'] = __cf + (__cp, offset, length) = get_u32(buf, offset, length) + ret['cp'] = __cp + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -421,6 +418,35 @@ def _unpack_members(self, buf, offset, length): self.cf = res['cf'] self.cp = res['cp'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # job_type: u8 + ret += 1 + # status: u8 + ret += 1 + # cn0: u16 + ret += 2 + # int_time: u8 + ret += 1 + # sid: GnssSignalDep + ret += GnssSignalDep._payload_size() + # bin_width: u16 + ret += 2 + # timestamp: u32 + ret += 4 + # time_spent: u32 + ret += 4 + # cf_min: s32 + ret += 4 + # cf_max: s32 + ret += 4 + # cf: s32 + ret += 4 + # cp: u32 + ret += 4 + return ret SBP_MSG_ACQ_SV_PROFILE = 0x002E class MsgAcqSvProfile(SBP): @@ -440,13 +466,10 @@ class MsgAcqSvProfile(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__acq_sv_profile, offset, length) = offset, get_array(AcqSvProfile.parse_members)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'acq_sv_profile' : __acq_sv_profile, - }, offset, length + ret = {} + (__acq_sv_profile, offset, length) = get_array(AcqSvProfile.parse_members)(buf, offset, length) + ret['acq_sv_profile'] = __acq_sv_profile + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -454,6 +477,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.acq_sv_profile = res['acq_sv_profile'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # acq_sv_profile: array of AcqSvProfile + ret += 247 + return ret SBP_MSG_ACQ_SV_PROFILE_DEP = 0x001E class MsgAcqSvProfileDep(SBP): @@ -471,13 +501,10 @@ class MsgAcqSvProfileDep(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__acq_sv_profile, offset, length) = offset, get_array(AcqSvProfileDep.parse_members)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'acq_sv_profile' : __acq_sv_profile, - }, offset, length + ret = {} + (__acq_sv_profile, offset, length) = get_array(AcqSvProfileDep.parse_members)(buf, offset, length) + ret['acq_sv_profile'] = __acq_sv_profile + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -485,6 +512,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.acq_sv_profile = res['acq_sv_profile'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # acq_sv_profile: array of AcqSvProfileDep + ret += 247 + return ret msg_classes = { diff --git a/python/sbp/jit/bootload.py b/python/sbp/jit/bootload.py index 31fb6ab6c2..5d64d6928a 100644 --- a/python/sbp/jit/bootload.py +++ b/python/sbp/jit/bootload.py @@ -21,11 +21,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array # Automatically generated from piksi/yaml/swiftnav/sbp/bootload.yaml with generate.py. @@ -46,6 +48,11 @@ class MsgBootloaderHandshakeReq(SBP): """ __slots__ = [] + def _unpack_members(self, buf, offset, length): + return {}, offset, length + + def _payload_size(self): + return 0 SBP_MSG_BOOTLOADER_HANDSHAKE_RESP = 0x00B4 class MsgBootloaderHandshakeResp(SBP): @@ -69,17 +76,12 @@ class MsgBootloaderHandshakeResp(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__flags, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__version, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'flags' : __flags, - 'version' : __version, - }, offset, length + ret = {} + (__flags, offset, length) = get_u32(buf, offset, length) + ret['flags'] = __flags + (__version, offset, length) = get_string(buf, offset, length) + ret['version'] = __version + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -88,6 +90,15 @@ def _unpack_members(self, buf, offset, length): self.flags = res['flags'] self.version = res['version'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # flags: u32 + ret += 4 + # version: string + ret += 247 + return ret SBP_MSG_BOOTLOADER_JUMP_TO_APP = 0x00B1 class MsgBootloaderJumpToApp(SBP): @@ -106,13 +117,10 @@ class MsgBootloaderJumpToApp(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__jump, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'jump' : __jump, - }, offset, length + ret = {} + (__jump, offset, length) = get_u8(buf, offset, length) + ret['jump'] = __jump + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -120,6 +128,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.jump = res['jump'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # jump: u8 + ret += 1 + return ret SBP_MSG_NAP_DEVICE_DNA_REQ = 0x00DE class MsgNapDeviceDnaReq(SBP): @@ -140,6 +155,11 @@ class MsgNapDeviceDnaReq(SBP): """ __slots__ = [] + def _unpack_members(self, buf, offset, length): + return {}, offset, length + + def _payload_size(self): + return 0 SBP_MSG_NAP_DEVICE_DNA_RESP = 0x00DD class MsgNapDeviceDnaResp(SBP): @@ -163,13 +183,10 @@ class MsgNapDeviceDnaResp(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__dna, offset, length) = offset, get_fixed_array(get_u8, 8, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'dna' : __dna, - }, offset, length + ret = {} + (__dna, offset, length) = get_fixed_array(get_u8, 8, 1)(buf, offset, length) + ret['dna'] = __dna + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -177,6 +194,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.dna = res['dna'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # dna: array of u8 + ret += 1 * 8 + return ret SBP_MSG_BOOTLOADER_HANDSHAKE_DEP_A = 0x00B0 class MsgBootloaderHandshakeDepA(SBP): @@ -194,13 +218,10 @@ class MsgBootloaderHandshakeDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__handshake, offset, length) = offset, get_array(get_u8)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'handshake' : __handshake, - }, offset, length + ret = {} + (__handshake, offset, length) = get_array(get_u8)(buf, offset, length) + ret['handshake'] = __handshake + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -208,6 +229,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.handshake = res['handshake'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # handshake: array of u8 + ret += 247 + return ret msg_classes = { diff --git a/python/sbp/jit/ext_events.py b/python/sbp/jit/ext_events.py index 89af765a68..2d755f06f1 100644 --- a/python/sbp/jit/ext_events.py +++ b/python/sbp/jit/ext_events.py @@ -18,11 +18,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array # Automatically generated from piksi/yaml/swiftnav/sbp/ext_events.yaml with generate.py. @@ -49,29 +51,18 @@ class MsgExtEvent(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__wn, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ns_residual, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pin, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'wn' : __wn, - 'tow' : __tow, - 'ns_residual' : __ns_residual, - 'flags' : __flags, - 'pin' : __pin, - }, offset, length + ret = {} + (__wn, offset, length) = get_u16(buf, offset, length) + ret['wn'] = __wn + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__ns_residual, offset, length) = get_s32(buf, offset, length) + ret['ns_residual'] = __ns_residual + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + (__pin, offset, length) = get_u8(buf, offset, length) + ret['pin'] = __pin + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -83,6 +74,21 @@ def _unpack_members(self, buf, offset, length): self.flags = res['flags'] self.pin = res['pin'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # wn: u16 + ret += 2 + # tow: u32 + ret += 4 + # ns_residual: s32 + ret += 4 + # flags: u8 + ret += 1 + # pin: u8 + ret += 1 + return ret msg_classes = { diff --git a/python/sbp/jit/file_io.py b/python/sbp/jit/file_io.py index e2e542574a..024888644b 100644 --- a/python/sbp/jit/file_io.py +++ b/python/sbp/jit/file_io.py @@ -24,11 +24,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array # Automatically generated from piksi/yaml/swiftnav/sbp/file_io.yaml with generate.py. @@ -60,25 +62,16 @@ class MsgFileioReadReq(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__offset, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__chunk_size, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__filename, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sequence' : __sequence, - 'offset' : __offset, - 'chunk_size' : __chunk_size, - 'filename' : __filename, - }, offset, length + ret = {} + (__sequence, offset, length) = get_u32(buf, offset, length) + ret['sequence'] = __sequence + (__offset, offset, length) = get_u32(buf, offset, length) + ret['offset'] = __offset + (__chunk_size, offset, length) = get_u8(buf, offset, length) + ret['chunk_size'] = __chunk_size + (__filename, offset, length) = get_string(buf, offset, length) + ret['filename'] = __filename + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -89,6 +82,19 @@ def _unpack_members(self, buf, offset, length): self.chunk_size = res['chunk_size'] self.filename = res['filename'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sequence: u32 + ret += 4 + # offset: u32 + ret += 4 + # chunk_size: u8 + ret += 1 + # filename: string + ret += 247 + return ret SBP_MSG_FILEIO_READ_RESP = 0x00A3 class MsgFileioReadResp(SBP): @@ -112,17 +118,12 @@ class MsgFileioReadResp(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__contents, offset, length) = offset, get_array(get_u8)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sequence' : __sequence, - 'contents' : __contents, - }, offset, length + ret = {} + (__sequence, offset, length) = get_u32(buf, offset, length) + ret['sequence'] = __sequence + (__contents, offset, length) = get_array(get_u8)(buf, offset, length) + ret['contents'] = __contents + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -131,6 +132,15 @@ def _unpack_members(self, buf, offset, length): self.sequence = res['sequence'] self.contents = res['contents'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sequence: u32 + ret += 4 + # contents: array of u8 + ret += 247 + return ret SBP_MSG_FILEIO_READ_DIR_REQ = 0x00A9 class MsgFileioReadDirReq(SBP): @@ -160,21 +170,14 @@ class MsgFileioReadDirReq(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__offset, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__dirname, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sequence' : __sequence, - 'offset' : __offset, - 'dirname' : __dirname, - }, offset, length + ret = {} + (__sequence, offset, length) = get_u32(buf, offset, length) + ret['sequence'] = __sequence + (__offset, offset, length) = get_u32(buf, offset, length) + ret['offset'] = __offset + (__dirname, offset, length) = get_string(buf, offset, length) + ret['dirname'] = __dirname + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -184,6 +187,17 @@ def _unpack_members(self, buf, offset, length): self.offset = res['offset'] self.dirname = res['dirname'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sequence: u32 + ret += 4 + # offset: u32 + ret += 4 + # dirname: string + ret += 247 + return ret SBP_MSG_FILEIO_READ_DIR_RESP = 0x00AA class MsgFileioReadDirResp(SBP): @@ -208,17 +222,12 @@ class MsgFileioReadDirResp(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__contents, offset, length) = offset, get_array(get_u8)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sequence' : __sequence, - 'contents' : __contents, - }, offset, length + ret = {} + (__sequence, offset, length) = get_u32(buf, offset, length) + ret['sequence'] = __sequence + (__contents, offset, length) = get_array(get_u8)(buf, offset, length) + ret['contents'] = __contents + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -227,6 +236,15 @@ def _unpack_members(self, buf, offset, length): self.sequence = res['sequence'] self.contents = res['contents'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sequence: u32 + ret += 4 + # contents: array of u8 + ret += 247 + return ret SBP_MSG_FILEIO_REMOVE = 0x00AC class MsgFileioRemove(SBP): @@ -248,13 +266,10 @@ class MsgFileioRemove(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__filename, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'filename' : __filename, - }, offset, length + ret = {} + (__filename, offset, length) = get_string(buf, offset, length) + ret['filename'] = __filename + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -262,6 +277,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.filename = res['filename'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # filename: string + ret += 247 + return ret SBP_MSG_FILEIO_WRITE_REQ = 0x00AD class MsgFileioWriteReq(SBP): @@ -290,25 +312,16 @@ class MsgFileioWriteReq(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__offset, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__filename, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__data, offset, length) = offset, get_array(get_u8)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sequence' : __sequence, - 'offset' : __offset, - 'filename' : __filename, - 'data' : __data, - }, offset, length + ret = {} + (__sequence, offset, length) = get_u32(buf, offset, length) + ret['sequence'] = __sequence + (__offset, offset, length) = get_u32(buf, offset, length) + ret['offset'] = __offset + (__filename, offset, length) = get_string(buf, offset, length) + ret['filename'] = __filename + (__data, offset, length) = get_array(get_u8)(buf, offset, length) + ret['data'] = __data + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -319,6 +332,19 @@ def _unpack_members(self, buf, offset, length): self.filename = res['filename'] self.data = res['data'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sequence: u32 + ret += 4 + # offset: u32 + ret += 4 + # filename: string + ret += 247 + # data: array of u8 + ret += 247 + return ret SBP_MSG_FILEIO_WRITE_RESP = 0x00AB class MsgFileioWriteResp(SBP): @@ -341,13 +367,10 @@ class MsgFileioWriteResp(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sequence' : __sequence, - }, offset, length + ret = {} + (__sequence, offset, length) = get_u32(buf, offset, length) + ret['sequence'] = __sequence + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -355,6 +378,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.sequence = res['sequence'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sequence: u32 + ret += 4 + return ret SBP_MSG_FILEIO_CONFIG_REQ = 0x1001 class MsgFileioConfigReq(SBP): @@ -376,13 +406,10 @@ class MsgFileioConfigReq(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sequence' : __sequence, - }, offset, length + ret = {} + (__sequence, offset, length) = get_u32(buf, offset, length) + ret['sequence'] = __sequence + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -390,6 +417,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.sequence = res['sequence'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sequence: u32 + ret += 4 + return ret SBP_MSG_FILEIO_CONFIG_RESP = 0x1002 class MsgFileioConfigResp(SBP): @@ -414,25 +448,16 @@ class MsgFileioConfigResp(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__window_size, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__batch_size, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__fileio_version, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sequence' : __sequence, - 'window_size' : __window_size, - 'batch_size' : __batch_size, - 'fileio_version' : __fileio_version, - }, offset, length + ret = {} + (__sequence, offset, length) = get_u32(buf, offset, length) + ret['sequence'] = __sequence + (__window_size, offset, length) = get_u32(buf, offset, length) + ret['window_size'] = __window_size + (__batch_size, offset, length) = get_u32(buf, offset, length) + ret['batch_size'] = __batch_size + (__fileio_version, offset, length) = get_u32(buf, offset, length) + ret['fileio_version'] = __fileio_version + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -443,6 +468,19 @@ def _unpack_members(self, buf, offset, length): self.batch_size = res['batch_size'] self.fileio_version = res['fileio_version'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sequence: u32 + ret += 4 + # window_size: u32 + ret += 4 + # batch_size: u32 + ret += 4 + # fileio_version: u32 + ret += 4 + return ret msg_classes = { diff --git a/python/sbp/jit/flash.py b/python/sbp/jit/flash.py index 188e46c169..fa02fb1ee9 100644 --- a/python/sbp/jit/flash.py +++ b/python/sbp/jit/flash.py @@ -21,11 +21,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array # Automatically generated from piksi/yaml/swiftnav/sbp/flash.yaml with generate.py. @@ -55,25 +57,16 @@ class MsgFlashProgram(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__target, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__addr_start, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__addr_len, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__data, offset, length) = offset, get_array(get_u8)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'target' : __target, - 'addr_start' : __addr_start, - 'addr_len' : __addr_len, - 'data' : __data, - }, offset, length + ret = {} + (__target, offset, length) = get_u8(buf, offset, length) + ret['target'] = __target + (__addr_start, offset, length) = get_fixed_array(get_u8, 3, 1)(buf, offset, length) + ret['addr_start'] = __addr_start + (__addr_len, offset, length) = get_u8(buf, offset, length) + ret['addr_len'] = __addr_len + (__data, offset, length) = get_array(get_u8)(buf, offset, length) + ret['data'] = __data + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -84,6 +77,19 @@ def _unpack_members(self, buf, offset, length): self.addr_len = res['addr_len'] self.data = res['data'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # target: u8 + ret += 1 + # addr_start: array of u8 + ret += 1 * 3 + # addr_len: u8 + ret += 1 + # data: array of u8 + ret += 247 + return ret SBP_MSG_FLASH_DONE = 0x00E0 class MsgFlashDone(SBP): @@ -105,13 +111,10 @@ class MsgFlashDone(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__response, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'response' : __response, - }, offset, length + ret = {} + (__response, offset, length) = get_u8(buf, offset, length) + ret['response'] = __response + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -119,6 +122,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.response = res['response'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # response: u8 + ret += 1 + return ret SBP_MSG_FLASH_READ_REQ = 0x00E7 class MsgFlashReadReq(SBP): @@ -145,21 +155,14 @@ class MsgFlashReadReq(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__target, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__addr_start, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__addr_len, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'target' : __target, - 'addr_start' : __addr_start, - 'addr_len' : __addr_len, - }, offset, length + ret = {} + (__target, offset, length) = get_u8(buf, offset, length) + ret['target'] = __target + (__addr_start, offset, length) = get_fixed_array(get_u8, 3, 1)(buf, offset, length) + ret['addr_start'] = __addr_start + (__addr_len, offset, length) = get_u8(buf, offset, length) + ret['addr_len'] = __addr_len + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -169,6 +172,17 @@ def _unpack_members(self, buf, offset, length): self.addr_start = res['addr_start'] self.addr_len = res['addr_len'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # target: u8 + ret += 1 + # addr_start: array of u8 + ret += 1 * 3 + # addr_len: u8 + ret += 1 + return ret SBP_MSG_FLASH_READ_RESP = 0x00E1 class MsgFlashReadResp(SBP): @@ -195,21 +209,14 @@ class MsgFlashReadResp(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__target, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__addr_start, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__addr_len, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'target' : __target, - 'addr_start' : __addr_start, - 'addr_len' : __addr_len, - }, offset, length + ret = {} + (__target, offset, length) = get_u8(buf, offset, length) + ret['target'] = __target + (__addr_start, offset, length) = get_fixed_array(get_u8, 3, 1)(buf, offset, length) + ret['addr_start'] = __addr_start + (__addr_len, offset, length) = get_u8(buf, offset, length) + ret['addr_len'] = __addr_len + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -219,6 +226,17 @@ def _unpack_members(self, buf, offset, length): self.addr_start = res['addr_start'] self.addr_len = res['addr_len'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # target: u8 + ret += 1 + # addr_start: array of u8 + ret += 1 * 3 + # addr_len: u8 + ret += 1 + return ret SBP_MSG_FLASH_ERASE = 0x00E2 class MsgFlashErase(SBP): @@ -242,17 +260,12 @@ class MsgFlashErase(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__target, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sector_num, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'target' : __target, - 'sector_num' : __sector_num, - }, offset, length + ret = {} + (__target, offset, length) = get_u8(buf, offset, length) + ret['target'] = __target + (__sector_num, offset, length) = get_u32(buf, offset, length) + ret['sector_num'] = __sector_num + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -261,6 +274,15 @@ def _unpack_members(self, buf, offset, length): self.target = res['target'] self.sector_num = res['sector_num'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # target: u8 + ret += 1 + # sector_num: u32 + ret += 4 + return ret SBP_MSG_STM_FLASH_LOCK_SECTOR = 0x00E3 class MsgStmFlashLockSector(SBP): @@ -280,13 +302,10 @@ class MsgStmFlashLockSector(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sector, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sector' : __sector, - }, offset, length + ret = {} + (__sector, offset, length) = get_u32(buf, offset, length) + ret['sector'] = __sector + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -294,6 +313,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.sector = res['sector'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sector: u32 + ret += 4 + return ret SBP_MSG_STM_FLASH_UNLOCK_SECTOR = 0x00E4 class MsgStmFlashUnlockSector(SBP): @@ -313,13 +339,10 @@ class MsgStmFlashUnlockSector(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sector, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sector' : __sector, - }, offset, length + ret = {} + (__sector, offset, length) = get_u32(buf, offset, length) + ret['sector'] = __sector + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -327,6 +350,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.sector = res['sector'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sector: u32 + ret += 4 + return ret SBP_MSG_STM_UNIQUE_ID_REQ = 0x00E8 class MsgStmUniqueIdReq(SBP): @@ -345,6 +375,11 @@ class MsgStmUniqueIdReq(SBP): """ __slots__ = [] + def _unpack_members(self, buf, offset, length): + return {}, offset, length + + def _payload_size(self): + return 0 SBP_MSG_STM_UNIQUE_ID_RESP = 0x00E5 class MsgStmUniqueIdResp(SBP): @@ -366,13 +401,10 @@ class MsgStmUniqueIdResp(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__stm_id, offset, length) = offset, get_fixed_array(get_u8, 12, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'stm_id' : __stm_id, - }, offset, length + ret = {} + (__stm_id, offset, length) = get_fixed_array(get_u8, 12, 1)(buf, offset, length) + ret['stm_id'] = __stm_id + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -380,6 +412,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.stm_id = res['stm_id'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # stm_id: array of u8 + ret += 1 * 12 + return ret SBP_MSG_M25_FLASH_WRITE_STATUS = 0x00F3 class MsgM25FlashWriteStatus(SBP): @@ -399,13 +438,10 @@ class MsgM25FlashWriteStatus(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__status, offset, length) = offset, get_fixed_array(get_u8, 1, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'status' : __status, - }, offset, length + ret = {} + (__status, offset, length) = get_fixed_array(get_u8, 1, 1)(buf, offset, length) + ret['status'] = __status + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -413,6 +449,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.status = res['status'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # status: array of u8 + ret += 1 * 1 + return ret msg_classes = { diff --git a/python/sbp/jit/gnss.py b/python/sbp/jit/gnss.py index da81a3ca19..c681acd927 100644 --- a/python/sbp/jit/gnss.py +++ b/python/sbp/jit/gnss.py @@ -16,11 +16,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array # Automatically generated from piksi/yaml/swiftnav/sbp/gnss.yaml with generate.py. @@ -42,17 +44,12 @@ class GnssSignal(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sat, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__code, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sat' : __sat, - 'code' : __code, - }, offset, length + ret = {} + (__sat, offset, length) = get_u8(buf, offset, length) + ret['sat'] = __sat + (__code, offset, length) = get_u8(buf, offset, length) + ret['code'] = __code + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -61,6 +58,15 @@ def _unpack_members(self, buf, offset, length): self.sat = res['sat'] self.code = res['code'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sat: u8 + ret += 1 + # code: u8 + ret += 1 + return ret class GnssSignalDep(object): """SBP class for message GnssSignalDep @@ -79,21 +85,14 @@ class GnssSignalDep(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sat, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__code, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__reserved, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sat' : __sat, - 'code' : __code, - 'reserved' : __reserved, - }, offset, length + ret = {} + (__sat, offset, length) = get_u16(buf, offset, length) + ret['sat'] = __sat + (__code, offset, length) = get_u8(buf, offset, length) + ret['code'] = __code + (__reserved, offset, length) = get_u8(buf, offset, length) + ret['reserved'] = __reserved + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -103,6 +102,17 @@ def _unpack_members(self, buf, offset, length): self.code = res['code'] self.reserved = res['reserved'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sat: u16 + ret += 2 + # code: u8 + ret += 1 + # reserved: u8 + ret += 1 + return ret class GPSTimeDep(object): """SBP class for message GPSTimeDep @@ -123,17 +133,12 @@ class GPSTimeDep(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__wn, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'wn' : __wn, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__wn, offset, length) = get_u16(buf, offset, length) + ret['wn'] = __wn + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -142,6 +147,15 @@ def _unpack_members(self, buf, offset, length): self.tow = res['tow'] self.wn = res['wn'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # wn: u16 + ret += 2 + return ret class GPSTimeSec(object): """SBP class for message GPSTimeSec @@ -162,17 +176,12 @@ class GPSTimeSec(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__wn, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'wn' : __wn, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__wn, offset, length) = get_u16(buf, offset, length) + ret['wn'] = __wn + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -181,6 +190,15 @@ def _unpack_members(self, buf, offset, length): self.tow = res['tow'] self.wn = res['wn'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # wn: u16 + ret += 2 + return ret class GPSTime(object): """SBP class for message GPSTime @@ -203,21 +221,14 @@ class GPSTime(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ns_residual, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__wn, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'ns_residual' : __ns_residual, - 'wn' : __wn, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__ns_residual, offset, length) = get_s32(buf, offset, length) + ret['ns_residual'] = __ns_residual + (__wn, offset, length) = get_u16(buf, offset, length) + ret['wn'] = __wn + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -227,6 +238,17 @@ def _unpack_members(self, buf, offset, length): self.ns_residual = res['ns_residual'] self.wn = res['wn'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # ns_residual: s32 + ret += 4 + # wn: u16 + ret += 2 + return ret class CarrierPhase(object): """SBP class for message CarrierPhase @@ -248,17 +270,12 @@ class CarrierPhase(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__i, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__f, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'i' : __i, - 'f' : __f, - }, offset, length + ret = {} + (__i, offset, length) = get_s32(buf, offset, length) + ret['i'] = __i + (__f, offset, length) = get_u8(buf, offset, length) + ret['f'] = __f + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -267,6 +284,15 @@ def _unpack_members(self, buf, offset, length): self.i = res['i'] self.f = res['f'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # i: s32 + ret += 4 + # f: u8 + ret += 1 + return ret msg_classes = { diff --git a/python/sbp/jit/imu.py b/python/sbp/jit/imu.py index 6a4be740c6..d255e1bb21 100644 --- a/python/sbp/jit/imu.py +++ b/python/sbp/jit/imu.py @@ -16,11 +16,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array # Automatically generated from piksi/yaml/swiftnav/sbp/imu.yaml with generate.py. @@ -52,41 +54,24 @@ class MsgImuRaw(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tow_f, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__acc_x, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__acc_y, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__acc_z, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__gyr_x, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__gyr_y, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__gyr_z, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'tow_f' : __tow_f, - 'acc_x' : __acc_x, - 'acc_y' : __acc_y, - 'acc_z' : __acc_z, - 'gyr_x' : __gyr_x, - 'gyr_y' : __gyr_y, - 'gyr_z' : __gyr_z, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__tow_f, offset, length) = get_u8(buf, offset, length) + ret['tow_f'] = __tow_f + (__acc_x, offset, length) = get_s16(buf, offset, length) + ret['acc_x'] = __acc_x + (__acc_y, offset, length) = get_s16(buf, offset, length) + ret['acc_y'] = __acc_y + (__acc_z, offset, length) = get_s16(buf, offset, length) + ret['acc_z'] = __acc_z + (__gyr_x, offset, length) = get_s16(buf, offset, length) + ret['gyr_x'] = __gyr_x + (__gyr_y, offset, length) = get_s16(buf, offset, length) + ret['gyr_y'] = __gyr_y + (__gyr_z, offset, length) = get_s16(buf, offset, length) + ret['gyr_z'] = __gyr_z + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -101,6 +86,27 @@ def _unpack_members(self, buf, offset, length): self.gyr_y = res['gyr_y'] self.gyr_z = res['gyr_z'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # tow_f: u8 + ret += 1 + # acc_x: s16 + ret += 2 + # acc_y: s16 + ret += 2 + # acc_z: s16 + ret += 2 + # gyr_x: s16 + ret += 2 + # gyr_y: s16 + ret += 2 + # gyr_z: s16 + ret += 2 + return ret SBP_MSG_IMU_AUX = 0x0901 class MsgImuAux(SBP): @@ -123,21 +129,14 @@ class MsgImuAux(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__imu_type, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__temp, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__imu_conf, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'imu_type' : __imu_type, - 'temp' : __temp, - 'imu_conf' : __imu_conf, - }, offset, length + ret = {} + (__imu_type, offset, length) = get_u8(buf, offset, length) + ret['imu_type'] = __imu_type + (__temp, offset, length) = get_s16(buf, offset, length) + ret['temp'] = __temp + (__imu_conf, offset, length) = get_u8(buf, offset, length) + ret['imu_conf'] = __imu_conf + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -147,6 +146,17 @@ def _unpack_members(self, buf, offset, length): self.temp = res['temp'] self.imu_conf = res['imu_conf'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # imu_type: u8 + ret += 1 + # temp: s16 + ret += 2 + # imu_conf: u8 + ret += 1 + return ret msg_classes = { diff --git a/python/sbp/jit/linux.py b/python/sbp/jit/linux.py index 277d07cdf8..fcf6fc07ec 100644 --- a/python/sbp/jit/linux.py +++ b/python/sbp/jit/linux.py @@ -17,11 +17,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array # Automatically generated from piksi/yaml/swiftnav/sbp/linux.yaml with generate.py. @@ -48,29 +50,18 @@ class MsgLinuxCpuState(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__index, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pid, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pcpu, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tname, offset, length) = offset, get_fixed_string(15)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cmdline, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'index' : __index, - 'pid' : __pid, - 'pcpu' : __pcpu, - 'tname' : __tname, - 'cmdline' : __cmdline, - }, offset, length + ret = {} + (__index, offset, length) = get_u8(buf, offset, length) + ret['index'] = __index + (__pid, offset, length) = get_u16(buf, offset, length) + ret['pid'] = __pid + (__pcpu, offset, length) = get_u8(buf, offset, length) + ret['pcpu'] = __pcpu + (__tname, offset, length) = get_fixed_string(15)(buf, offset, length) + ret['tname'] = __tname + (__cmdline, offset, length) = get_string(buf, offset, length) + ret['cmdline'] = __cmdline + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -82,6 +73,21 @@ def _unpack_members(self, buf, offset, length): self.tname = res['tname'] self.cmdline = res['cmdline'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # index: u8 + ret += 1 + # pid: u16 + ret += 2 + # pcpu: u8 + ret += 1 + # tname: string + ret += 15 + # cmdline: string + ret += 247 + return ret SBP_MSG_LINUX_MEM_STATE = 0x7F01 class MsgLinuxMemState(SBP): @@ -105,29 +111,18 @@ class MsgLinuxMemState(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__index, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pid, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pmem, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tname, offset, length) = offset, get_fixed_string(15)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cmdline, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'index' : __index, - 'pid' : __pid, - 'pmem' : __pmem, - 'tname' : __tname, - 'cmdline' : __cmdline, - }, offset, length + ret = {} + (__index, offset, length) = get_u8(buf, offset, length) + ret['index'] = __index + (__pid, offset, length) = get_u16(buf, offset, length) + ret['pid'] = __pid + (__pmem, offset, length) = get_u8(buf, offset, length) + ret['pmem'] = __pmem + (__tname, offset, length) = get_fixed_string(15)(buf, offset, length) + ret['tname'] = __tname + (__cmdline, offset, length) = get_string(buf, offset, length) + ret['cmdline'] = __cmdline + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -139,6 +134,21 @@ def _unpack_members(self, buf, offset, length): self.tname = res['tname'] self.cmdline = res['cmdline'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # index: u8 + ret += 1 + # pid: u16 + ret += 2 + # pmem: u8 + ret += 1 + # tname: string + ret += 15 + # cmdline: string + ret += 247 + return ret SBP_MSG_LINUX_SYS_STATE = 0x7F02 class MsgLinuxSysState(SBP): @@ -162,33 +172,20 @@ class MsgLinuxSysState(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__mem_total, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pcpu, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pmem, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__procs_starting, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__procs_stopping, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pid_count, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'mem_total' : __mem_total, - 'pcpu' : __pcpu, - 'pmem' : __pmem, - 'procs_starting' : __procs_starting, - 'procs_stopping' : __procs_stopping, - 'pid_count' : __pid_count, - }, offset, length + ret = {} + (__mem_total, offset, length) = get_u16(buf, offset, length) + ret['mem_total'] = __mem_total + (__pcpu, offset, length) = get_u8(buf, offset, length) + ret['pcpu'] = __pcpu + (__pmem, offset, length) = get_u8(buf, offset, length) + ret['pmem'] = __pmem + (__procs_starting, offset, length) = get_u16(buf, offset, length) + ret['procs_starting'] = __procs_starting + (__procs_stopping, offset, length) = get_u16(buf, offset, length) + ret['procs_stopping'] = __procs_stopping + (__pid_count, offset, length) = get_u16(buf, offset, length) + ret['pid_count'] = __pid_count + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -201,6 +198,23 @@ def _unpack_members(self, buf, offset, length): self.procs_stopping = res['procs_stopping'] self.pid_count = res['pid_count'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # mem_total: u16 + ret += 2 + # pcpu: u8 + ret += 1 + # pmem: u8 + ret += 1 + # procs_starting: u16 + ret += 2 + # procs_stopping: u16 + ret += 2 + # pid_count: u16 + ret += 2 + return ret SBP_MSG_LINUX_PROCESS_SOCKET_COUNTS = 0x7F03 class MsgLinuxProcessSocketCounts(SBP): @@ -224,33 +238,20 @@ class MsgLinuxProcessSocketCounts(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__index, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pid, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__socket_count, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__socket_types, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__socket_states, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cmdline, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'index' : __index, - 'pid' : __pid, - 'socket_count' : __socket_count, - 'socket_types' : __socket_types, - 'socket_states' : __socket_states, - 'cmdline' : __cmdline, - }, offset, length + ret = {} + (__index, offset, length) = get_u8(buf, offset, length) + ret['index'] = __index + (__pid, offset, length) = get_u16(buf, offset, length) + ret['pid'] = __pid + (__socket_count, offset, length) = get_u16(buf, offset, length) + ret['socket_count'] = __socket_count + (__socket_types, offset, length) = get_u16(buf, offset, length) + ret['socket_types'] = __socket_types + (__socket_states, offset, length) = get_u16(buf, offset, length) + ret['socket_states'] = __socket_states + (__cmdline, offset, length) = get_string(buf, offset, length) + ret['cmdline'] = __cmdline + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -263,6 +264,23 @@ def _unpack_members(self, buf, offset, length): self.socket_states = res['socket_states'] self.cmdline = res['cmdline'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # index: u8 + ret += 1 + # pid: u16 + ret += 2 + # socket_count: u16 + ret += 2 + # socket_types: u16 + ret += 2 + # socket_states: u16 + ret += 2 + # cmdline: string + ret += 247 + return ret SBP_MSG_LINUX_PROCESS_SOCKET_QUEUES = 0x7F04 class MsgLinuxProcessSocketQueues(SBP): @@ -288,41 +306,24 @@ class MsgLinuxProcessSocketQueues(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__index, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pid, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__recv_queued, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__send_queued, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__socket_types, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__socket_states, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__address_of_largest, offset, length) = offset, get_fixed_string(64)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cmdline, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'index' : __index, - 'pid' : __pid, - 'recv_queued' : __recv_queued, - 'send_queued' : __send_queued, - 'socket_types' : __socket_types, - 'socket_states' : __socket_states, - 'address_of_largest' : __address_of_largest, - 'cmdline' : __cmdline, - }, offset, length + ret = {} + (__index, offset, length) = get_u8(buf, offset, length) + ret['index'] = __index + (__pid, offset, length) = get_u16(buf, offset, length) + ret['pid'] = __pid + (__recv_queued, offset, length) = get_u16(buf, offset, length) + ret['recv_queued'] = __recv_queued + (__send_queued, offset, length) = get_u16(buf, offset, length) + ret['send_queued'] = __send_queued + (__socket_types, offset, length) = get_u16(buf, offset, length) + ret['socket_types'] = __socket_types + (__socket_states, offset, length) = get_u16(buf, offset, length) + ret['socket_states'] = __socket_states + (__address_of_largest, offset, length) = get_fixed_string(64)(buf, offset, length) + ret['address_of_largest'] = __address_of_largest + (__cmdline, offset, length) = get_string(buf, offset, length) + ret['cmdline'] = __cmdline + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -337,6 +338,27 @@ def _unpack_members(self, buf, offset, length): self.address_of_largest = res['address_of_largest'] self.cmdline = res['cmdline'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # index: u8 + ret += 1 + # pid: u16 + ret += 2 + # recv_queued: u16 + ret += 2 + # send_queued: u16 + ret += 2 + # socket_types: u16 + ret += 2 + # socket_states: u16 + ret += 2 + # address_of_largest: string + ret += 64 + # cmdline: string + ret += 247 + return ret SBP_MSG_LINUX_SOCKET_USAGE = 0x7F05 class MsgLinuxSocketUsage(SBP): @@ -358,25 +380,16 @@ class MsgLinuxSocketUsage(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__avg_queue_depth, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__max_queue_depth, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__socket_state_counts, offset, length) = offset, get_fixed_array(get_u8, 16, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__socket_type_counts, offset, length) = offset, get_fixed_array(get_u8, 16, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'avg_queue_depth' : __avg_queue_depth, - 'max_queue_depth' : __max_queue_depth, - 'socket_state_counts' : __socket_state_counts, - 'socket_type_counts' : __socket_type_counts, - }, offset, length + ret = {} + (__avg_queue_depth, offset, length) = get_u32(buf, offset, length) + ret['avg_queue_depth'] = __avg_queue_depth + (__max_queue_depth, offset, length) = get_u32(buf, offset, length) + ret['max_queue_depth'] = __max_queue_depth + (__socket_state_counts, offset, length) = get_fixed_array(get_u16, 16, 2)(buf, offset, length) + ret['socket_state_counts'] = __socket_state_counts + (__socket_type_counts, offset, length) = get_fixed_array(get_u16, 16, 2)(buf, offset, length) + ret['socket_type_counts'] = __socket_type_counts + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -387,6 +400,19 @@ def _unpack_members(self, buf, offset, length): self.socket_state_counts = res['socket_state_counts'] self.socket_type_counts = res['socket_type_counts'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # avg_queue_depth: u32 + ret += 4 + # max_queue_depth: u32 + ret += 4 + # socket_state_counts: array of u16 + ret += 2 * 16 + # socket_type_counts: array of u16 + ret += 2 * 16 + return ret SBP_MSG_LINUX_PROCESS_FD_COUNT = 0x7F06 class MsgLinuxProcessFdCount(SBP): @@ -408,25 +434,16 @@ class MsgLinuxProcessFdCount(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__index, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pid, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__fd_count, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cmdline, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'index' : __index, - 'pid' : __pid, - 'fd_count' : __fd_count, - 'cmdline' : __cmdline, - }, offset, length + ret = {} + (__index, offset, length) = get_u8(buf, offset, length) + ret['index'] = __index + (__pid, offset, length) = get_u16(buf, offset, length) + ret['pid'] = __pid + (__fd_count, offset, length) = get_u16(buf, offset, length) + ret['fd_count'] = __fd_count + (__cmdline, offset, length) = get_string(buf, offset, length) + ret['cmdline'] = __cmdline + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -437,6 +454,19 @@ def _unpack_members(self, buf, offset, length): self.fd_count = res['fd_count'] self.cmdline = res['cmdline'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # index: u8 + ret += 1 + # pid: u16 + ret += 2 + # fd_count: u16 + ret += 2 + # cmdline: string + ret += 247 + return ret SBP_MSG_LINUX_PROCESS_FD_SUMMARY = 0x7F07 class MsgLinuxProcessFdSummary(SBP): @@ -456,17 +486,12 @@ class MsgLinuxProcessFdSummary(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sys_fd_count, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__most_opened, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sys_fd_count' : __sys_fd_count, - 'most_opened' : __most_opened, - }, offset, length + ret = {} + (__sys_fd_count, offset, length) = get_u32(buf, offset, length) + ret['sys_fd_count'] = __sys_fd_count + (__most_opened, offset, length) = get_string(buf, offset, length) + ret['most_opened'] = __most_opened + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -475,6 +500,15 @@ def _unpack_members(self, buf, offset, length): self.sys_fd_count = res['sys_fd_count'] self.most_opened = res['most_opened'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sys_fd_count: u32 + ret += 4 + # most_opened: string + ret += 247 + return ret msg_classes = { diff --git a/python/sbp/jit/logging.py b/python/sbp/jit/logging.py index dd244bf70d..a2787c4e57 100644 --- a/python/sbp/jit/logging.py +++ b/python/sbp/jit/logging.py @@ -17,11 +17,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array # Automatically generated from piksi/yaml/swiftnav/sbp/logging.yaml with generate.py. @@ -46,17 +48,12 @@ class MsgLog(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__level, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__text, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'level' : __level, - 'text' : __text, - }, offset, length + ret = {} + (__level, offset, length) = get_u8(buf, offset, length) + ret['level'] = __level + (__text, offset, length) = get_string(buf, offset, length) + ret['text'] = __text + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -65,6 +62,15 @@ def _unpack_members(self, buf, offset, length): self.level = res['level'] self.text = res['text'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # level: u8 + ret += 1 + # text: string + ret += 247 + return ret SBP_MSG_FWD = 0x0402 class MsgFwd(SBP): @@ -91,21 +97,14 @@ class MsgFwd(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__source, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__protocol, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__fwd_payload, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'source' : __source, - 'protocol' : __protocol, - 'fwd_payload' : __fwd_payload, - }, offset, length + ret = {} + (__source, offset, length) = get_u8(buf, offset, length) + ret['source'] = __source + (__protocol, offset, length) = get_u8(buf, offset, length) + ret['protocol'] = __protocol + (__fwd_payload, offset, length) = get_string(buf, offset, length) + ret['fwd_payload'] = __fwd_payload + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -115,6 +114,17 @@ def _unpack_members(self, buf, offset, length): self.protocol = res['protocol'] self.fwd_payload = res['fwd_payload'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # source: u8 + ret += 1 + # protocol: u8 + ret += 1 + # fwd_payload: string + ret += 247 + return ret SBP_MSG_PRINT_DEP = 0x0010 class MsgPrintDep(SBP): @@ -132,13 +142,10 @@ class MsgPrintDep(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__text, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'text' : __text, - }, offset, length + ret = {} + (__text, offset, length) = get_string(buf, offset, length) + ret['text'] = __text + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -146,6 +153,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.text = res['text'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # text: string + ret += 247 + return ret msg_classes = { diff --git a/python/sbp/jit/mag.py b/python/sbp/jit/mag.py index 827a36caf8..419a018851 100644 --- a/python/sbp/jit/mag.py +++ b/python/sbp/jit/mag.py @@ -16,11 +16,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array # Automatically generated from piksi/yaml/swiftnav/sbp/mag.yaml with generate.py. @@ -46,29 +48,18 @@ class MsgMagRaw(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tow_f, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__mag_x, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__mag_y, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__mag_z, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'tow_f' : __tow_f, - 'mag_x' : __mag_x, - 'mag_y' : __mag_y, - 'mag_z' : __mag_z, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__tow_f, offset, length) = get_u8(buf, offset, length) + ret['tow_f'] = __tow_f + (__mag_x, offset, length) = get_s16(buf, offset, length) + ret['mag_x'] = __mag_x + (__mag_y, offset, length) = get_s16(buf, offset, length) + ret['mag_y'] = __mag_y + (__mag_z, offset, length) = get_s16(buf, offset, length) + ret['mag_z'] = __mag_z + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -80,6 +71,21 @@ def _unpack_members(self, buf, offset, length): self.mag_y = res['mag_y'] self.mag_z = res['mag_z'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # tow_f: u8 + ret += 1 + # mag_x: s16 + ret += 2 + # mag_y: s16 + ret += 2 + # mag_z: s16 + ret += 2 + return ret msg_classes = { diff --git a/python/sbp/jit/navigation.py b/python/sbp/jit/navigation.py index c3496b40fc..d88fd3968d 100644 --- a/python/sbp/jit/navigation.py +++ b/python/sbp/jit/navigation.py @@ -34,11 +34,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array # Automatically generated from piksi/yaml/swiftnav/sbp/navigation.yaml with generate.py. @@ -75,25 +77,16 @@ class MsgGPSTime(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__wn, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ns_residual, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'wn' : __wn, - 'tow' : __tow, - 'ns_residual' : __ns_residual, - 'flags' : __flags, - }, offset, length + ret = {} + (__wn, offset, length) = get_u16(buf, offset, length) + ret['wn'] = __wn + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__ns_residual, offset, length) = get_s32(buf, offset, length) + ret['ns_residual'] = __ns_residual + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -104,6 +97,19 @@ def _unpack_members(self, buf, offset, length): self.ns_residual = res['ns_residual'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # wn: u16 + ret += 2 + # tow: u32 + ret += 4 + # ns_residual: s32 + ret += 4 + # flags: u8 + ret += 1 + return ret SBP_MSG_UTC_TIME = 0x0103 class MsgUtcTime(SBP): @@ -131,45 +137,26 @@ class MsgUtcTime(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__year, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__month, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__day, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__hours, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__minutes, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__seconds, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ns, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'flags' : __flags, - 'tow' : __tow, - 'year' : __year, - 'month' : __month, - 'day' : __day, - 'hours' : __hours, - 'minutes' : __minutes, - 'seconds' : __seconds, - 'ns' : __ns, - }, offset, length + ret = {} + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__year, offset, length) = get_u16(buf, offset, length) + ret['year'] = __year + (__month, offset, length) = get_u8(buf, offset, length) + ret['month'] = __month + (__day, offset, length) = get_u8(buf, offset, length) + ret['day'] = __day + (__hours, offset, length) = get_u8(buf, offset, length) + ret['hours'] = __hours + (__minutes, offset, length) = get_u8(buf, offset, length) + ret['minutes'] = __minutes + (__seconds, offset, length) = get_u8(buf, offset, length) + ret['seconds'] = __seconds + (__ns, offset, length) = get_u32(buf, offset, length) + ret['ns'] = __ns + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -185,6 +172,29 @@ def _unpack_members(self, buf, offset, length): self.seconds = res['seconds'] self.ns = res['ns'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # flags: u8 + ret += 1 + # tow: u32 + ret += 4 + # year: u16 + ret += 2 + # month: u8 + ret += 1 + # day: u8 + ret += 1 + # hours: u8 + ret += 1 + # minutes: u8 + ret += 1 + # seconds: u8 + ret += 1 + # ns: u32 + ret += 4 + return ret SBP_MSG_DOPS = 0x0208 class MsgDops(SBP): @@ -212,37 +222,22 @@ class MsgDops(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__gdop, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pdop, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tdop, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__hdop, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__vdop, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'gdop' : __gdop, - 'pdop' : __pdop, - 'tdop' : __tdop, - 'hdop' : __hdop, - 'vdop' : __vdop, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__gdop, offset, length) = get_u16(buf, offset, length) + ret['gdop'] = __gdop + (__pdop, offset, length) = get_u16(buf, offset, length) + ret['pdop'] = __pdop + (__tdop, offset, length) = get_u16(buf, offset, length) + ret['tdop'] = __tdop + (__hdop, offset, length) = get_u16(buf, offset, length) + ret['hdop'] = __hdop + (__vdop, offset, length) = get_u16(buf, offset, length) + ret['vdop'] = __vdop + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -256,6 +251,25 @@ def _unpack_members(self, buf, offset, length): self.vdop = res['vdop'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # gdop: u16 + ret += 2 + # pdop: u16 + ret += 2 + # tdop: u16 + ret += 2 + # hdop: u16 + ret += 2 + # vdop: u16 + ret += 2 + # flags: u8 + ret += 1 + return ret SBP_MSG_POS_ECEF = 0x0209 class MsgPosECEF(SBP): @@ -287,37 +301,22 @@ class MsgPosECEF(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__x, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__y, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__z, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'x' : __x, - 'y' : __y, - 'z' : __z, - 'accuracy' : __accuracy, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__x, offset, length) = get_f64(buf, offset, length) + ret['x'] = __x + (__y, offset, length) = get_f64(buf, offset, length) + ret['y'] = __y + (__z, offset, length) = get_f64(buf, offset, length) + ret['z'] = __z + (__accuracy, offset, length) = get_u16(buf, offset, length) + ret['accuracy'] = __accuracy + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -331,6 +330,25 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # x: double + ret += 8 + # y: double + ret += 8 + # z: double + ret += 8 + # accuracy: u16 + ret += 2 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_POS_ECEF_COV = 0x0214 class MsgPosECEFCov(SBP): @@ -368,57 +386,32 @@ class MsgPosECEFCov(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__x, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__y, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__z, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_x_x, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_x_y, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_x_z, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_y_y, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_y_z, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_z_z, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'x' : __x, - 'y' : __y, - 'z' : __z, - 'cov_x_x' : __cov_x_x, - 'cov_x_y' : __cov_x_y, - 'cov_x_z' : __cov_x_z, - 'cov_y_y' : __cov_y_y, - 'cov_y_z' : __cov_y_z, - 'cov_z_z' : __cov_z_z, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__x, offset, length) = get_f64(buf, offset, length) + ret['x'] = __x + (__y, offset, length) = get_f64(buf, offset, length) + ret['y'] = __y + (__z, offset, length) = get_f64(buf, offset, length) + ret['z'] = __z + (__cov_x_x, offset, length) = get_f32(buf, offset, length) + ret['cov_x_x'] = judicious_round(nb.f4(__cov_x_x)) if SBP.judicious_rounding else __cov_x_x + (__cov_x_y, offset, length) = get_f32(buf, offset, length) + ret['cov_x_y'] = judicious_round(nb.f4(__cov_x_y)) if SBP.judicious_rounding else __cov_x_y + (__cov_x_z, offset, length) = get_f32(buf, offset, length) + ret['cov_x_z'] = judicious_round(nb.f4(__cov_x_z)) if SBP.judicious_rounding else __cov_x_z + (__cov_y_y, offset, length) = get_f32(buf, offset, length) + ret['cov_y_y'] = judicious_round(nb.f4(__cov_y_y)) if SBP.judicious_rounding else __cov_y_y + (__cov_y_z, offset, length) = get_f32(buf, offset, length) + ret['cov_y_z'] = judicious_round(nb.f4(__cov_y_z)) if SBP.judicious_rounding else __cov_y_z + (__cov_z_z, offset, length) = get_f32(buf, offset, length) + ret['cov_z_z'] = judicious_round(nb.f4(__cov_z_z)) if SBP.judicious_rounding else __cov_z_z + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -437,6 +430,35 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # x: double + ret += 8 + # y: double + ret += 8 + # z: double + ret += 8 + # cov_x_x: float + ret += 4 + # cov_x_y: float + ret += 4 + # cov_x_z: float + ret += 4 + # cov_y_y: float + ret += 4 + # cov_y_z: float + ret += 4 + # cov_z_z: float + ret += 4 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_POS_LLH = 0x020A class MsgPosLLH(SBP): @@ -469,41 +491,24 @@ class MsgPosLLH(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__lat, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__lon, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__height, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__h_accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__v_accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'lat' : __lat, - 'lon' : __lon, - 'height' : __height, - 'h_accuracy' : __h_accuracy, - 'v_accuracy' : __v_accuracy, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__lat, offset, length) = get_f64(buf, offset, length) + ret['lat'] = __lat + (__lon, offset, length) = get_f64(buf, offset, length) + ret['lon'] = __lon + (__height, offset, length) = get_f64(buf, offset, length) + ret['height'] = __height + (__h_accuracy, offset, length) = get_u16(buf, offset, length) + ret['h_accuracy'] = __h_accuracy + (__v_accuracy, offset, length) = get_u16(buf, offset, length) + ret['v_accuracy'] = __v_accuracy + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -518,6 +523,27 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # lat: double + ret += 8 + # lon: double + ret += 8 + # height: double + ret += 8 + # h_accuracy: u16 + ret += 2 + # v_accuracy: u16 + ret += 2 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_POS_LLH_COV = 0x0211 class MsgPosLLHCov(SBP): @@ -554,57 +580,32 @@ class MsgPosLLHCov(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__lat, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__lon, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__height, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_n_n, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_n_e, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_n_d, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_e_e, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_e_d, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_d_d, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'lat' : __lat, - 'lon' : __lon, - 'height' : __height, - 'cov_n_n' : __cov_n_n, - 'cov_n_e' : __cov_n_e, - 'cov_n_d' : __cov_n_d, - 'cov_e_e' : __cov_e_e, - 'cov_e_d' : __cov_e_d, - 'cov_d_d' : __cov_d_d, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__lat, offset, length) = get_f64(buf, offset, length) + ret['lat'] = __lat + (__lon, offset, length) = get_f64(buf, offset, length) + ret['lon'] = __lon + (__height, offset, length) = get_f64(buf, offset, length) + ret['height'] = __height + (__cov_n_n, offset, length) = get_f32(buf, offset, length) + ret['cov_n_n'] = judicious_round(nb.f4(__cov_n_n)) if SBP.judicious_rounding else __cov_n_n + (__cov_n_e, offset, length) = get_f32(buf, offset, length) + ret['cov_n_e'] = judicious_round(nb.f4(__cov_n_e)) if SBP.judicious_rounding else __cov_n_e + (__cov_n_d, offset, length) = get_f32(buf, offset, length) + ret['cov_n_d'] = judicious_round(nb.f4(__cov_n_d)) if SBP.judicious_rounding else __cov_n_d + (__cov_e_e, offset, length) = get_f32(buf, offset, length) + ret['cov_e_e'] = judicious_round(nb.f4(__cov_e_e)) if SBP.judicious_rounding else __cov_e_e + (__cov_e_d, offset, length) = get_f32(buf, offset, length) + ret['cov_e_d'] = judicious_round(nb.f4(__cov_e_d)) if SBP.judicious_rounding else __cov_e_d + (__cov_d_d, offset, length) = get_f32(buf, offset, length) + ret['cov_d_d'] = judicious_round(nb.f4(__cov_d_d)) if SBP.judicious_rounding else __cov_d_d + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -623,6 +624,35 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # lat: double + ret += 8 + # lon: double + ret += 8 + # height: double + ret += 8 + # cov_n_n: float + ret += 4 + # cov_n_e: float + ret += 4 + # cov_n_d: float + ret += 4 + # cov_e_e: float + ret += 4 + # cov_e_d: float + ret += 4 + # cov_d_d: float + ret += 4 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_BASELINE_ECEF = 0x020B class MsgBaselineECEF(SBP): @@ -651,37 +681,22 @@ class MsgBaselineECEF(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__x, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__y, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__z, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'x' : __x, - 'y' : __y, - 'z' : __z, - 'accuracy' : __accuracy, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__x, offset, length) = get_s32(buf, offset, length) + ret['x'] = __x + (__y, offset, length) = get_s32(buf, offset, length) + ret['y'] = __y + (__z, offset, length) = get_s32(buf, offset, length) + ret['z'] = __z + (__accuracy, offset, length) = get_u16(buf, offset, length) + ret['accuracy'] = __accuracy + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -695,6 +710,25 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # x: s32 + ret += 4 + # y: s32 + ret += 4 + # z: s32 + ret += 4 + # accuracy: u16 + ret += 2 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_BASELINE_NED = 0x020C class MsgBaselineNED(SBP): @@ -725,41 +759,24 @@ class MsgBaselineNED(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__e, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__d, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__h_accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__v_accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'n' : __n, - 'e' : __e, - 'd' : __d, - 'h_accuracy' : __h_accuracy, - 'v_accuracy' : __v_accuracy, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__n, offset, length) = get_s32(buf, offset, length) + ret['n'] = __n + (__e, offset, length) = get_s32(buf, offset, length) + ret['e'] = __e + (__d, offset, length) = get_s32(buf, offset, length) + ret['d'] = __d + (__h_accuracy, offset, length) = get_u16(buf, offset, length) + ret['h_accuracy'] = __h_accuracy + (__v_accuracy, offset, length) = get_u16(buf, offset, length) + ret['v_accuracy'] = __v_accuracy + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -774,6 +791,27 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # n: s32 + ret += 4 + # e: s32 + ret += 4 + # d: s32 + ret += 4 + # h_accuracy: u16 + ret += 2 + # v_accuracy: u16 + ret += 2 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_VEL_ECEF = 0x020D class MsgVelECEF(SBP): @@ -800,37 +838,22 @@ class MsgVelECEF(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__x, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__y, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__z, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'x' : __x, - 'y' : __y, - 'z' : __z, - 'accuracy' : __accuracy, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__x, offset, length) = get_s32(buf, offset, length) + ret['x'] = __x + (__y, offset, length) = get_s32(buf, offset, length) + ret['y'] = __y + (__z, offset, length) = get_s32(buf, offset, length) + ret['z'] = __z + (__accuracy, offset, length) = get_u16(buf, offset, length) + ret['accuracy'] = __accuracy + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -844,6 +867,25 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # x: s32 + ret += 4 + # y: s32 + ret += 4 + # z: s32 + ret += 4 + # accuracy: u16 + ret += 2 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_VEL_ECEF_COV = 0x0215 class MsgVelECEFCov(SBP): @@ -875,57 +917,32 @@ class MsgVelECEFCov(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__x, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__y, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__z, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_x_x, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_x_y, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_x_z, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_y_y, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_y_z, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_z_z, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'x' : __x, - 'y' : __y, - 'z' : __z, - 'cov_x_x' : __cov_x_x, - 'cov_x_y' : __cov_x_y, - 'cov_x_z' : __cov_x_z, - 'cov_y_y' : __cov_y_y, - 'cov_y_z' : __cov_y_z, - 'cov_z_z' : __cov_z_z, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__x, offset, length) = get_s32(buf, offset, length) + ret['x'] = __x + (__y, offset, length) = get_s32(buf, offset, length) + ret['y'] = __y + (__z, offset, length) = get_s32(buf, offset, length) + ret['z'] = __z + (__cov_x_x, offset, length) = get_f32(buf, offset, length) + ret['cov_x_x'] = judicious_round(nb.f4(__cov_x_x)) if SBP.judicious_rounding else __cov_x_x + (__cov_x_y, offset, length) = get_f32(buf, offset, length) + ret['cov_x_y'] = judicious_round(nb.f4(__cov_x_y)) if SBP.judicious_rounding else __cov_x_y + (__cov_x_z, offset, length) = get_f32(buf, offset, length) + ret['cov_x_z'] = judicious_round(nb.f4(__cov_x_z)) if SBP.judicious_rounding else __cov_x_z + (__cov_y_y, offset, length) = get_f32(buf, offset, length) + ret['cov_y_y'] = judicious_round(nb.f4(__cov_y_y)) if SBP.judicious_rounding else __cov_y_y + (__cov_y_z, offset, length) = get_f32(buf, offset, length) + ret['cov_y_z'] = judicious_round(nb.f4(__cov_y_z)) if SBP.judicious_rounding else __cov_y_z + (__cov_z_z, offset, length) = get_f32(buf, offset, length) + ret['cov_z_z'] = judicious_round(nb.f4(__cov_z_z)) if SBP.judicious_rounding else __cov_z_z + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -944,6 +961,35 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # x: s32 + ret += 4 + # y: s32 + ret += 4 + # z: s32 + ret += 4 + # cov_x_x: float + ret += 4 + # cov_x_y: float + ret += 4 + # cov_x_z: float + ret += 4 + # cov_y_y: float + ret += 4 + # cov_y_z: float + ret += 4 + # cov_z_z: float + ret += 4 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_VEL_NED = 0x020E class MsgVelNED(SBP): @@ -972,41 +1018,24 @@ class MsgVelNED(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__e, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__d, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__h_accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__v_accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'n' : __n, - 'e' : __e, - 'd' : __d, - 'h_accuracy' : __h_accuracy, - 'v_accuracy' : __v_accuracy, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__n, offset, length) = get_s32(buf, offset, length) + ret['n'] = __n + (__e, offset, length) = get_s32(buf, offset, length) + ret['e'] = __e + (__d, offset, length) = get_s32(buf, offset, length) + ret['d'] = __d + (__h_accuracy, offset, length) = get_u16(buf, offset, length) + ret['h_accuracy'] = __h_accuracy + (__v_accuracy, offset, length) = get_u16(buf, offset, length) + ret['v_accuracy'] = __v_accuracy + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1021,6 +1050,27 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # n: s32 + ret += 4 + # e: s32 + ret += 4 + # d: s32 + ret += 4 + # h_accuracy: u16 + ret += 2 + # v_accuracy: u16 + ret += 2 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_VEL_NED_COV = 0x0212 class MsgVelNEDCov(SBP): @@ -1055,57 +1105,32 @@ class MsgVelNEDCov(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__e, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__d, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_n_n, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_n_e, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_n_d, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_e_e, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_e_d, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_d_d, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'n' : __n, - 'e' : __e, - 'd' : __d, - 'cov_n_n' : __cov_n_n, - 'cov_n_e' : __cov_n_e, - 'cov_n_d' : __cov_n_d, - 'cov_e_e' : __cov_e_e, - 'cov_e_d' : __cov_e_d, - 'cov_d_d' : __cov_d_d, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__n, offset, length) = get_s32(buf, offset, length) + ret['n'] = __n + (__e, offset, length) = get_s32(buf, offset, length) + ret['e'] = __e + (__d, offset, length) = get_s32(buf, offset, length) + ret['d'] = __d + (__cov_n_n, offset, length) = get_f32(buf, offset, length) + ret['cov_n_n'] = judicious_round(nb.f4(__cov_n_n)) if SBP.judicious_rounding else __cov_n_n + (__cov_n_e, offset, length) = get_f32(buf, offset, length) + ret['cov_n_e'] = judicious_round(nb.f4(__cov_n_e)) if SBP.judicious_rounding else __cov_n_e + (__cov_n_d, offset, length) = get_f32(buf, offset, length) + ret['cov_n_d'] = judicious_round(nb.f4(__cov_n_d)) if SBP.judicious_rounding else __cov_n_d + (__cov_e_e, offset, length) = get_f32(buf, offset, length) + ret['cov_e_e'] = judicious_round(nb.f4(__cov_e_e)) if SBP.judicious_rounding else __cov_e_e + (__cov_e_d, offset, length) = get_f32(buf, offset, length) + ret['cov_e_d'] = judicious_round(nb.f4(__cov_e_d)) if SBP.judicious_rounding else __cov_e_d + (__cov_d_d, offset, length) = get_f32(buf, offset, length) + ret['cov_d_d'] = judicious_round(nb.f4(__cov_d_d)) if SBP.judicious_rounding else __cov_d_d + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1124,6 +1149,35 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # n: s32 + ret += 4 + # e: s32 + ret += 4 + # d: s32 + ret += 4 + # cov_n_n: float + ret += 4 + # cov_n_e: float + ret += 4 + # cov_n_d: float + ret += 4 + # cov_e_e: float + ret += 4 + # cov_e_d: float + ret += 4 + # cov_d_d: float + ret += 4 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_VEL_BODY = 0x0213 class MsgVelBody(SBP): @@ -1160,57 +1214,32 @@ class MsgVelBody(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__x, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__y, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__z, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_x_x, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_x_y, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_x_z, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_y_y, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_y_z, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cov_z_z, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'x' : __x, - 'y' : __y, - 'z' : __z, - 'cov_x_x' : __cov_x_x, - 'cov_x_y' : __cov_x_y, - 'cov_x_z' : __cov_x_z, - 'cov_y_y' : __cov_y_y, - 'cov_y_z' : __cov_y_z, - 'cov_z_z' : __cov_z_z, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__x, offset, length) = get_s32(buf, offset, length) + ret['x'] = __x + (__y, offset, length) = get_s32(buf, offset, length) + ret['y'] = __y + (__z, offset, length) = get_s32(buf, offset, length) + ret['z'] = __z + (__cov_x_x, offset, length) = get_f32(buf, offset, length) + ret['cov_x_x'] = judicious_round(nb.f4(__cov_x_x)) if SBP.judicious_rounding else __cov_x_x + (__cov_x_y, offset, length) = get_f32(buf, offset, length) + ret['cov_x_y'] = judicious_round(nb.f4(__cov_x_y)) if SBP.judicious_rounding else __cov_x_y + (__cov_x_z, offset, length) = get_f32(buf, offset, length) + ret['cov_x_z'] = judicious_round(nb.f4(__cov_x_z)) if SBP.judicious_rounding else __cov_x_z + (__cov_y_y, offset, length) = get_f32(buf, offset, length) + ret['cov_y_y'] = judicious_round(nb.f4(__cov_y_y)) if SBP.judicious_rounding else __cov_y_y + (__cov_y_z, offset, length) = get_f32(buf, offset, length) + ret['cov_y_z'] = judicious_round(nb.f4(__cov_y_z)) if SBP.judicious_rounding else __cov_y_z + (__cov_z_z, offset, length) = get_f32(buf, offset, length) + ret['cov_z_z'] = judicious_round(nb.f4(__cov_z_z)) if SBP.judicious_rounding else __cov_z_z + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1229,6 +1258,35 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # x: s32 + ret += 4 + # y: s32 + ret += 4 + # z: s32 + ret += 4 + # cov_x_x: float + ret += 4 + # cov_x_y: float + ret += 4 + # cov_x_z: float + ret += 4 + # cov_y_y: float + ret += 4 + # cov_y_z: float + ret += 4 + # cov_z_z: float + ret += 4 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_AGE_CORRECTIONS = 0x0210 class MsgAgeCorrections(SBP): @@ -1249,17 +1307,12 @@ class MsgAgeCorrections(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__age, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'age' : __age, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__age, offset, length) = get_u16(buf, offset, length) + ret['age'] = __age + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1268,6 +1321,15 @@ def _unpack_members(self, buf, offset, length): self.tow = res['tow'] self.age = res['age'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # age: u16 + ret += 2 + return ret SBP_MSG_GPS_TIME_DEP_A = 0x0100 class MsgGPSTimeDepA(SBP): @@ -1301,25 +1363,16 @@ class MsgGPSTimeDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__wn, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ns_residual, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'wn' : __wn, - 'tow' : __tow, - 'ns_residual' : __ns_residual, - 'flags' : __flags, - }, offset, length + ret = {} + (__wn, offset, length) = get_u16(buf, offset, length) + ret['wn'] = __wn + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__ns_residual, offset, length) = get_s32(buf, offset, length) + ret['ns_residual'] = __ns_residual + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1330,6 +1383,19 @@ def _unpack_members(self, buf, offset, length): self.ns_residual = res['ns_residual'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # wn: u16 + ret += 2 + # tow: u32 + ret += 4 + # ns_residual: s32 + ret += 4 + # flags: u8 + ret += 1 + return ret SBP_MSG_DOPS_DEP_A = 0x0206 class MsgDopsDepA(SBP): @@ -1355,33 +1421,20 @@ class MsgDopsDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__gdop, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pdop, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tdop, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__hdop, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__vdop, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'gdop' : __gdop, - 'pdop' : __pdop, - 'tdop' : __tdop, - 'hdop' : __hdop, - 'vdop' : __vdop, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__gdop, offset, length) = get_u16(buf, offset, length) + ret['gdop'] = __gdop + (__pdop, offset, length) = get_u16(buf, offset, length) + ret['pdop'] = __pdop + (__tdop, offset, length) = get_u16(buf, offset, length) + ret['tdop'] = __tdop + (__hdop, offset, length) = get_u16(buf, offset, length) + ret['hdop'] = __hdop + (__vdop, offset, length) = get_u16(buf, offset, length) + ret['vdop'] = __vdop + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1394,6 +1447,23 @@ def _unpack_members(self, buf, offset, length): self.hdop = res['hdop'] self.vdop = res['vdop'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # gdop: u16 + ret += 2 + # pdop: u16 + ret += 2 + # tdop: u16 + ret += 2 + # hdop: u16 + ret += 2 + # vdop: u16 + ret += 2 + return ret SBP_MSG_POS_ECEF_DEP_A = 0x0200 class MsgPosECEFDepA(SBP): @@ -1425,37 +1495,22 @@ class MsgPosECEFDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__x, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__y, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__z, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'x' : __x, - 'y' : __y, - 'z' : __z, - 'accuracy' : __accuracy, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__x, offset, length) = get_f64(buf, offset, length) + ret['x'] = __x + (__y, offset, length) = get_f64(buf, offset, length) + ret['y'] = __y + (__z, offset, length) = get_f64(buf, offset, length) + ret['z'] = __z + (__accuracy, offset, length) = get_u16(buf, offset, length) + ret['accuracy'] = __accuracy + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1469,6 +1524,25 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # x: double + ret += 8 + # y: double + ret += 8 + # z: double + ret += 8 + # accuracy: u16 + ret += 2 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_POS_LLH_DEP_A = 0x0201 class MsgPosLLHDepA(SBP): @@ -1501,41 +1575,24 @@ class MsgPosLLHDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__lat, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__lon, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__height, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__h_accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__v_accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'lat' : __lat, - 'lon' : __lon, - 'height' : __height, - 'h_accuracy' : __h_accuracy, - 'v_accuracy' : __v_accuracy, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__lat, offset, length) = get_f64(buf, offset, length) + ret['lat'] = __lat + (__lon, offset, length) = get_f64(buf, offset, length) + ret['lon'] = __lon + (__height, offset, length) = get_f64(buf, offset, length) + ret['height'] = __height + (__h_accuracy, offset, length) = get_u16(buf, offset, length) + ret['h_accuracy'] = __h_accuracy + (__v_accuracy, offset, length) = get_u16(buf, offset, length) + ret['v_accuracy'] = __v_accuracy + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1550,6 +1607,27 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # lat: double + ret += 8 + # lon: double + ret += 8 + # height: double + ret += 8 + # h_accuracy: u16 + ret += 2 + # v_accuracy: u16 + ret += 2 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_BASELINE_ECEF_DEP_A = 0x0202 class MsgBaselineECEFDepA(SBP): @@ -1578,37 +1656,22 @@ class MsgBaselineECEFDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__x, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__y, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__z, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'x' : __x, - 'y' : __y, - 'z' : __z, - 'accuracy' : __accuracy, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__x, offset, length) = get_s32(buf, offset, length) + ret['x'] = __x + (__y, offset, length) = get_s32(buf, offset, length) + ret['y'] = __y + (__z, offset, length) = get_s32(buf, offset, length) + ret['z'] = __z + (__accuracy, offset, length) = get_u16(buf, offset, length) + ret['accuracy'] = __accuracy + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1622,6 +1685,25 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # x: s32 + ret += 4 + # y: s32 + ret += 4 + # z: s32 + ret += 4 + # accuracy: u16 + ret += 2 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_BASELINE_NED_DEP_A = 0x0203 class MsgBaselineNEDDepA(SBP): @@ -1652,41 +1734,24 @@ class MsgBaselineNEDDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__e, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__d, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__h_accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__v_accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'n' : __n, - 'e' : __e, - 'd' : __d, - 'h_accuracy' : __h_accuracy, - 'v_accuracy' : __v_accuracy, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__n, offset, length) = get_s32(buf, offset, length) + ret['n'] = __n + (__e, offset, length) = get_s32(buf, offset, length) + ret['e'] = __e + (__d, offset, length) = get_s32(buf, offset, length) + ret['d'] = __d + (__h_accuracy, offset, length) = get_u16(buf, offset, length) + ret['h_accuracy'] = __h_accuracy + (__v_accuracy, offset, length) = get_u16(buf, offset, length) + ret['v_accuracy'] = __v_accuracy + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1701,6 +1766,27 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # n: s32 + ret += 4 + # e: s32 + ret += 4 + # d: s32 + ret += 4 + # h_accuracy: u16 + ret += 2 + # v_accuracy: u16 + ret += 2 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_VEL_ECEF_DEP_A = 0x0204 class MsgVelECEFDepA(SBP): @@ -1727,37 +1813,22 @@ class MsgVelECEFDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__x, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__y, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__z, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'x' : __x, - 'y' : __y, - 'z' : __z, - 'accuracy' : __accuracy, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__x, offset, length) = get_s32(buf, offset, length) + ret['x'] = __x + (__y, offset, length) = get_s32(buf, offset, length) + ret['y'] = __y + (__z, offset, length) = get_s32(buf, offset, length) + ret['z'] = __z + (__accuracy, offset, length) = get_u16(buf, offset, length) + ret['accuracy'] = __accuracy + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1771,6 +1842,25 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # x: s32 + ret += 4 + # y: s32 + ret += 4 + # z: s32 + ret += 4 + # accuracy: u16 + ret += 2 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_VEL_NED_DEP_A = 0x0205 class MsgVelNEDDepA(SBP): @@ -1799,41 +1889,24 @@ class MsgVelNEDDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__e, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__d, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__h_accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__v_accuracy, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'n' : __n, - 'e' : __e, - 'd' : __d, - 'h_accuracy' : __h_accuracy, - 'v_accuracy' : __v_accuracy, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__n, offset, length) = get_s32(buf, offset, length) + ret['n'] = __n + (__e, offset, length) = get_s32(buf, offset, length) + ret['e'] = __e + (__d, offset, length) = get_s32(buf, offset, length) + ret['d'] = __d + (__h_accuracy, offset, length) = get_u16(buf, offset, length) + ret['h_accuracy'] = __h_accuracy + (__v_accuracy, offset, length) = get_u16(buf, offset, length) + ret['v_accuracy'] = __v_accuracy + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1848,6 +1921,27 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # n: s32 + ret += 4 + # e: s32 + ret += 4 + # d: s32 + ret += 4 + # h_accuracy: u16 + ret += 2 + # v_accuracy: u16 + ret += 2 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_BASELINE_HEADING_DEP_A = 0x0207 class MsgBaselineHeadingDepA(SBP): @@ -1871,25 +1965,16 @@ class MsgBaselineHeadingDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__heading, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'heading' : __heading, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__heading, offset, length) = get_u32(buf, offset, length) + ret['heading'] = __heading + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1900,6 +1985,19 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # heading: u32 + ret += 4 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret msg_classes = { diff --git a/python/sbp/jit/ndb.py b/python/sbp/jit/ndb.py index aefbe066f8..e10f3290ef 100644 --- a/python/sbp/jit/ndb.py +++ b/python/sbp/jit/ndb.py @@ -17,11 +17,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array from sbp.jit.gnss import * @@ -52,41 +54,24 @@ class MsgNdbEvent(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__recv_time, offset, length) = offset, get_u64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__event, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__object_type, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__result, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__data_source, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__object_sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__src_sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__original_sender, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'recv_time' : __recv_time, - 'event' : __event, - 'object_type' : __object_type, - 'result' : __result, - 'data_source' : __data_source, - 'object_sid' : __object_sid, - 'src_sid' : __src_sid, - 'original_sender' : __original_sender, - }, offset, length + ret = {} + (__recv_time, offset, length) = get_u64(buf, offset, length) + ret['recv_time'] = __recv_time + (__event, offset, length) = get_u8(buf, offset, length) + ret['event'] = __event + (__object_type, offset, length) = get_u8(buf, offset, length) + ret['object_type'] = __object_type + (__result, offset, length) = get_u8(buf, offset, length) + ret['result'] = __result + (__data_source, offset, length) = get_u8(buf, offset, length) + ret['data_source'] = __data_source + (__object_sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['object_sid'] = __object_sid + (__src_sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['src_sid'] = __src_sid + (__original_sender, offset, length) = get_u16(buf, offset, length) + ret['original_sender'] = __original_sender + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -101,6 +86,27 @@ def _unpack_members(self, buf, offset, length): self.src_sid = res['src_sid'] self.original_sender = res['original_sender'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # recv_time: u64 + ret += 8 + # event: u8 + ret += 1 + # object_type: u8 + ret += 1 + # result: u8 + ret += 1 + # data_source: u8 + ret += 1 + # object_sid: GnssSignal + ret += GnssSignal._payload_size() + # src_sid: GnssSignal + ret += GnssSignal._payload_size() + # original_sender: u16 + ret += 2 + return ret msg_classes = { diff --git a/python/sbp/jit/observation.py b/python/sbp/jit/observation.py index 01691f0d41..89494748c9 100644 --- a/python/sbp/jit/observation.py +++ b/python/sbp/jit/observation.py @@ -16,11 +16,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array from sbp.jit.gnss import * @@ -42,17 +44,12 @@ class ObservationHeader(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__t, offset, length) = offset, GPSTime.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_obs, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 't' : __t, - 'n_obs' : __n_obs, - }, offset, length + ret = {} + (__t, offset, length) = GPSTime.parse_members(buf, offset, length) + ret['t'] = __t + (__n_obs, offset, length) = get_u8(buf, offset, length) + ret['n_obs'] = __n_obs + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -61,6 +58,15 @@ def _unpack_members(self, buf, offset, length): self.t = res['t'] self.n_obs = res['n_obs'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # t: GPSTime + ret += GPSTime._payload_size() + # n_obs: u8 + ret += 1 + return ret class Doppler(object): """SBP class for message Doppler @@ -82,17 +88,12 @@ class Doppler(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__i, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__f, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'i' : __i, - 'f' : __f, - }, offset, length + ret = {} + (__i, offset, length) = get_s16(buf, offset, length) + ret['i'] = __i + (__f, offset, length) = get_u8(buf, offset, length) + ret['f'] = __f + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -101,6 +102,15 @@ def _unpack_members(self, buf, offset, length): self.i = res['i'] self.f = res['f'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # i: s16 + ret += 2 + # f: u8 + ret += 1 + return ret class PackedObsContent(object): """SBP class for message PackedObsContent @@ -130,37 +140,22 @@ class PackedObsContent(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__P, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__L, offset, length) = offset, CarrierPhase.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__D, offset, length) = offset, Doppler.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cn0, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__lock, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'P' : __P, - 'L' : __L, - 'D' : __D, - 'cn0' : __cn0, - 'lock' : __lock, - 'flags' : __flags, - 'sid' : __sid, - }, offset, length + ret = {} + (__P, offset, length) = get_u32(buf, offset, length) + ret['P'] = __P + (__L, offset, length) = CarrierPhase.parse_members(buf, offset, length) + ret['L'] = __L + (__D, offset, length) = Doppler.parse_members(buf, offset, length) + ret['D'] = __D + (__cn0, offset, length) = get_u8(buf, offset, length) + ret['cn0'] = __cn0 + (__lock, offset, length) = get_u8(buf, offset, length) + ret['lock'] = __lock + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -174,6 +169,102 @@ def _unpack_members(self, buf, offset, length): self.flags = res['flags'] self.sid = res['sid'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # P: u32 + ret += 4 + # L: CarrierPhase + ret += CarrierPhase._payload_size() + # D: Doppler + ret += Doppler._payload_size() + # cn0: u8 + ret += 1 + # lock: u8 + ret += 1 + # flags: u8 + ret += 1 + # sid: GnssSignal + ret += GnssSignal._payload_size() + return ret + +class PackedOsrContent(object): + """SBP class for message PackedOsrContent + + You can have PackedOsrContent inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Pseudorange and carrier phase network corrections for a satellite signal. + + + """ + __slots__ = ['P', + 'L', + 'lock', + 'flags', + 'sid', + 'iono_std', + 'tropo_std', + 'range_std', + ] + @classmethod + def parse_members(cls, buf, offset, length): + ret = {} + (__P, offset, length) = get_u32(buf, offset, length) + ret['P'] = __P + (__L, offset, length) = CarrierPhase.parse_members(buf, offset, length) + ret['L'] = __L + (__lock, offset, length) = get_u8(buf, offset, length) + ret['lock'] = __lock + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + (__iono_std, offset, length) = get_u16(buf, offset, length) + ret['iono_std'] = __iono_std + (__tropo_std, offset, length) = get_u16(buf, offset, length) + ret['tropo_std'] = __tropo_std + (__range_std, offset, length) = get_u16(buf, offset, length) + ret['range_std'] = __range_std + return ret, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.P = res['P'] + self.L = res['L'] + self.lock = res['lock'] + self.flags = res['flags'] + self.sid = res['sid'] + self.iono_std = res['iono_std'] + self.tropo_std = res['tropo_std'] + self.range_std = res['range_std'] + return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # P: u32 + ret += 4 + # L: CarrierPhase + ret += CarrierPhase._payload_size() + # lock: u8 + ret += 1 + # flags: u8 + ret += 1 + # sid: GnssSignal + ret += GnssSignal._payload_size() + # iono_std: u16 + ret += 2 + # tropo_std: u16 + ret += 2 + # range_std: u16 + ret += 2 + return ret SBP_MSG_OBS = 0x004A class MsgObs(SBP): @@ -199,17 +290,12 @@ class MsgObs(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__header, offset, length) = offset, ObservationHeader.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__obs, offset, length) = offset, get_array(PackedObsContent.parse_members)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'header' : __header, - 'obs' : __obs, - }, offset, length + ret = {} + (__header, offset, length) = ObservationHeader.parse_members(buf, offset, length) + ret['header'] = __header + (__obs, offset, length) = get_array(PackedObsContent.parse_members)(buf, offset, length) + ret['obs'] = __obs + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -218,6 +304,15 @@ def _unpack_members(self, buf, offset, length): self.header = res['header'] self.obs = res['obs'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # header: ObservationHeader + ret += ObservationHeader._payload_size() + # obs: array of PackedObsContent + ret += 247 + return ret SBP_MSG_BASE_POS_LLH = 0x0044 class MsgBasePosLLH(SBP): @@ -242,21 +337,14 @@ class MsgBasePosLLH(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__lat, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__lon, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__height, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'lat' : __lat, - 'lon' : __lon, - 'height' : __height, - }, offset, length + ret = {} + (__lat, offset, length) = get_f64(buf, offset, length) + ret['lat'] = __lat + (__lon, offset, length) = get_f64(buf, offset, length) + ret['lon'] = __lon + (__height, offset, length) = get_f64(buf, offset, length) + ret['height'] = __height + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -266,6 +354,17 @@ def _unpack_members(self, buf, offset, length): self.lon = res['lon'] self.height = res['height'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # lat: double + ret += 8 + # lon: double + ret += 8 + # height: double + ret += 8 + return ret SBP_MSG_BASE_POS_ECEF = 0x0048 class MsgBasePosECEF(SBP): @@ -291,21 +390,14 @@ class MsgBasePosECEF(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__x, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__y, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__z, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'x' : __x, - 'y' : __y, - 'z' : __z, - }, offset, length + ret = {} + (__x, offset, length) = get_f64(buf, offset, length) + ret['x'] = __x + (__y, offset, length) = get_f64(buf, offset, length) + ret['y'] = __y + (__z, offset, length) = get_f64(buf, offset, length) + ret['z'] = __z + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -315,6 +407,17 @@ def _unpack_members(self, buf, offset, length): self.y = res['y'] self.z = res['z'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # x: double + ret += 8 + # y: double + ret += 8 + # z: double + ret += 8 + return ret class EphemerisCommonContent(object): """SBP class for message EphemerisCommonContent @@ -335,33 +438,20 @@ class EphemerisCommonContent(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toe, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ura, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__fit_interval, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__health_bits, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sid' : __sid, - 'toe' : __toe, - 'ura' : __ura, - 'fit_interval' : __fit_interval, - 'valid' : __valid, - 'health_bits' : __health_bits, - }, offset, length + ret = {} + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + (__toe, offset, length) = GPSTimeSec.parse_members(buf, offset, length) + ret['toe'] = __toe + (__ura, offset, length) = get_f32(buf, offset, length) + ret['ura'] = judicious_round(nb.f4(__ura)) if SBP.judicious_rounding else __ura + (__fit_interval, offset, length) = get_u32(buf, offset, length) + ret['fit_interval'] = __fit_interval + (__valid, offset, length) = get_u8(buf, offset, length) + ret['valid'] = __valid + (__health_bits, offset, length) = get_u8(buf, offset, length) + ret['health_bits'] = __health_bits + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -374,6 +464,23 @@ def _unpack_members(self, buf, offset, length): self.valid = res['valid'] self.health_bits = res['health_bits'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sid: GnssSignal + ret += GnssSignal._payload_size() + # toe: GPSTimeSec + ret += GPSTimeSec._payload_size() + # ura: float + ret += 4 + # fit_interval: u32 + ret += 4 + # valid: u8 + ret += 1 + # health_bits: u8 + ret += 1 + return ret class EphemerisCommonContentDepB(object): """SBP class for message EphemerisCommonContentDepB @@ -394,33 +501,20 @@ class EphemerisCommonContentDepB(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toe, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ura, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__fit_interval, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__health_bits, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sid' : __sid, - 'toe' : __toe, - 'ura' : __ura, - 'fit_interval' : __fit_interval, - 'valid' : __valid, - 'health_bits' : __health_bits, - }, offset, length + ret = {} + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + (__toe, offset, length) = GPSTimeSec.parse_members(buf, offset, length) + ret['toe'] = __toe + (__ura, offset, length) = get_f64(buf, offset, length) + ret['ura'] = __ura + (__fit_interval, offset, length) = get_u32(buf, offset, length) + ret['fit_interval'] = __fit_interval + (__valid, offset, length) = get_u8(buf, offset, length) + ret['valid'] = __valid + (__health_bits, offset, length) = get_u8(buf, offset, length) + ret['health_bits'] = __health_bits + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -433,6 +527,23 @@ def _unpack_members(self, buf, offset, length): self.valid = res['valid'] self.health_bits = res['health_bits'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sid: GnssSignal + ret += GnssSignal._payload_size() + # toe: GPSTimeSec + ret += GPSTimeSec._payload_size() + # ura: double + ret += 8 + # fit_interval: u32 + ret += 4 + # valid: u8 + ret += 1 + # health_bits: u8 + ret += 1 + return ret class EphemerisCommonContentDepA(object): """SBP class for message EphemerisCommonContentDepA @@ -453,33 +564,20 @@ class EphemerisCommonContentDepA(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toe, offset, length) = offset, GPSTimeDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ura, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__fit_interval, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__health_bits, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sid' : __sid, - 'toe' : __toe, - 'ura' : __ura, - 'fit_interval' : __fit_interval, - 'valid' : __valid, - 'health_bits' : __health_bits, - }, offset, length + ret = {} + (__sid, offset, length) = GnssSignalDep.parse_members(buf, offset, length) + ret['sid'] = __sid + (__toe, offset, length) = GPSTimeDep.parse_members(buf, offset, length) + ret['toe'] = __toe + (__ura, offset, length) = get_f64(buf, offset, length) + ret['ura'] = __ura + (__fit_interval, offset, length) = get_u32(buf, offset, length) + ret['fit_interval'] = __fit_interval + (__valid, offset, length) = get_u8(buf, offset, length) + ret['valid'] = __valid + (__health_bits, offset, length) = get_u8(buf, offset, length) + ret['health_bits'] = __health_bits + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -492,6 +590,23 @@ def _unpack_members(self, buf, offset, length): self.valid = res['valid'] self.health_bits = res['health_bits'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sid: GnssSignalDep + ret += GnssSignalDep._payload_size() + # toe: GPSTimeDep + ret += GPSTimeDep._payload_size() + # ura: double + ret += 8 + # fit_interval: u32 + ret += 4 + # valid: u8 + ret += 1 + # health_bits: u8 + ret += 1 + return ret SBP_MSG_EPHEMERIS_GPS_DEP_E = 0x0081 class MsgEphemerisGPSDepE(SBP): @@ -536,101 +651,54 @@ class MsgEphemerisGPSDepE(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__common, offset, length) = offset, EphemerisCommonContentDepA.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tgd, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rs, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_uc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_us, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_ic, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_is, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af2, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toc, offset, length) = offset, GPSTimeDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iode, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iodc, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'common' : __common, - 'tgd' : __tgd, - 'c_rs' : __c_rs, - 'c_rc' : __c_rc, - 'c_uc' : __c_uc, - 'c_us' : __c_us, - 'c_ic' : __c_ic, - 'c_is' : __c_is, - 'dn' : __dn, - 'm0' : __m0, - 'ecc' : __ecc, - 'sqrta' : __sqrta, - 'omega0' : __omega0, - 'omegadot' : __omegadot, - 'w' : __w, - 'inc' : __inc, - 'inc_dot' : __inc_dot, - 'af0' : __af0, - 'af1' : __af1, - 'af2' : __af2, - 'toc' : __toc, - 'iode' : __iode, - 'iodc' : __iodc, - }, offset, length + ret = {} + (__common, offset, length) = EphemerisCommonContentDepA.parse_members(buf, offset, length) + ret['common'] = __common + (__tgd, offset, length) = get_f64(buf, offset, length) + ret['tgd'] = __tgd + (__c_rs, offset, length) = get_f64(buf, offset, length) + ret['c_rs'] = __c_rs + (__c_rc, offset, length) = get_f64(buf, offset, length) + ret['c_rc'] = __c_rc + (__c_uc, offset, length) = get_f64(buf, offset, length) + ret['c_uc'] = __c_uc + (__c_us, offset, length) = get_f64(buf, offset, length) + ret['c_us'] = __c_us + (__c_ic, offset, length) = get_f64(buf, offset, length) + ret['c_ic'] = __c_ic + (__c_is, offset, length) = get_f64(buf, offset, length) + ret['c_is'] = __c_is + (__dn, offset, length) = get_f64(buf, offset, length) + ret['dn'] = __dn + (__m0, offset, length) = get_f64(buf, offset, length) + ret['m0'] = __m0 + (__ecc, offset, length) = get_f64(buf, offset, length) + ret['ecc'] = __ecc + (__sqrta, offset, length) = get_f64(buf, offset, length) + ret['sqrta'] = __sqrta + (__omega0, offset, length) = get_f64(buf, offset, length) + ret['omega0'] = __omega0 + (__omegadot, offset, length) = get_f64(buf, offset, length) + ret['omegadot'] = __omegadot + (__w, offset, length) = get_f64(buf, offset, length) + ret['w'] = __w + (__inc, offset, length) = get_f64(buf, offset, length) + ret['inc'] = __inc + (__inc_dot, offset, length) = get_f64(buf, offset, length) + ret['inc_dot'] = __inc_dot + (__af0, offset, length) = get_f64(buf, offset, length) + ret['af0'] = __af0 + (__af1, offset, length) = get_f64(buf, offset, length) + ret['af1'] = __af1 + (__af2, offset, length) = get_f64(buf, offset, length) + ret['af2'] = __af2 + (__toc, offset, length) = GPSTimeDep.parse_members(buf, offset, length) + ret['toc'] = __toc + (__iode, offset, length) = get_u8(buf, offset, length) + ret['iode'] = __iode + (__iodc, offset, length) = get_u16(buf, offset, length) + ret['iodc'] = __iodc + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -660,6 +728,57 @@ def _unpack_members(self, buf, offset, length): self.iode = res['iode'] self.iodc = res['iodc'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # common: EphemerisCommonContentDepA + ret += EphemerisCommonContentDepA._payload_size() + # tgd: double + ret += 8 + # c_rs: double + ret += 8 + # c_rc: double + ret += 8 + # c_uc: double + ret += 8 + # c_us: double + ret += 8 + # c_ic: double + ret += 8 + # c_is: double + ret += 8 + # dn: double + ret += 8 + # m0: double + ret += 8 + # ecc: double + ret += 8 + # sqrta: double + ret += 8 + # omega0: double + ret += 8 + # omegadot: double + ret += 8 + # w: double + ret += 8 + # inc: double + ret += 8 + # inc_dot: double + ret += 8 + # af0: double + ret += 8 + # af1: double + ret += 8 + # af2: double + ret += 8 + # toc: GPSTimeDep + ret += GPSTimeDep._payload_size() + # iode: u8 + ret += 1 + # iodc: u16 + ret += 2 + return ret SBP_MSG_EPHEMERIS_GPS_DEP_F = 0x0086 class MsgEphemerisGPSDepF(SBP): @@ -701,101 +820,54 @@ class MsgEphemerisGPSDepF(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__common, offset, length) = offset, EphemerisCommonContentDepB.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tgd, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rs, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_uc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_us, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_ic, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_is, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af2, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toc, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iode, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iodc, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'common' : __common, - 'tgd' : __tgd, - 'c_rs' : __c_rs, - 'c_rc' : __c_rc, - 'c_uc' : __c_uc, - 'c_us' : __c_us, - 'c_ic' : __c_ic, - 'c_is' : __c_is, - 'dn' : __dn, - 'm0' : __m0, - 'ecc' : __ecc, - 'sqrta' : __sqrta, - 'omega0' : __omega0, - 'omegadot' : __omegadot, - 'w' : __w, - 'inc' : __inc, - 'inc_dot' : __inc_dot, - 'af0' : __af0, - 'af1' : __af1, - 'af2' : __af2, - 'toc' : __toc, - 'iode' : __iode, - 'iodc' : __iodc, - }, offset, length + ret = {} + (__common, offset, length) = EphemerisCommonContentDepB.parse_members(buf, offset, length) + ret['common'] = __common + (__tgd, offset, length) = get_f64(buf, offset, length) + ret['tgd'] = __tgd + (__c_rs, offset, length) = get_f64(buf, offset, length) + ret['c_rs'] = __c_rs + (__c_rc, offset, length) = get_f64(buf, offset, length) + ret['c_rc'] = __c_rc + (__c_uc, offset, length) = get_f64(buf, offset, length) + ret['c_uc'] = __c_uc + (__c_us, offset, length) = get_f64(buf, offset, length) + ret['c_us'] = __c_us + (__c_ic, offset, length) = get_f64(buf, offset, length) + ret['c_ic'] = __c_ic + (__c_is, offset, length) = get_f64(buf, offset, length) + ret['c_is'] = __c_is + (__dn, offset, length) = get_f64(buf, offset, length) + ret['dn'] = __dn + (__m0, offset, length) = get_f64(buf, offset, length) + ret['m0'] = __m0 + (__ecc, offset, length) = get_f64(buf, offset, length) + ret['ecc'] = __ecc + (__sqrta, offset, length) = get_f64(buf, offset, length) + ret['sqrta'] = __sqrta + (__omega0, offset, length) = get_f64(buf, offset, length) + ret['omega0'] = __omega0 + (__omegadot, offset, length) = get_f64(buf, offset, length) + ret['omegadot'] = __omegadot + (__w, offset, length) = get_f64(buf, offset, length) + ret['w'] = __w + (__inc, offset, length) = get_f64(buf, offset, length) + ret['inc'] = __inc + (__inc_dot, offset, length) = get_f64(buf, offset, length) + ret['inc_dot'] = __inc_dot + (__af0, offset, length) = get_f64(buf, offset, length) + ret['af0'] = __af0 + (__af1, offset, length) = get_f64(buf, offset, length) + ret['af1'] = __af1 + (__af2, offset, length) = get_f64(buf, offset, length) + ret['af2'] = __af2 + (__toc, offset, length) = GPSTimeSec.parse_members(buf, offset, length) + ret['toc'] = __toc + (__iode, offset, length) = get_u8(buf, offset, length) + ret['iode'] = __iode + (__iodc, offset, length) = get_u16(buf, offset, length) + ret['iodc'] = __iodc + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -825,6 +897,57 @@ def _unpack_members(self, buf, offset, length): self.iode = res['iode'] self.iodc = res['iodc'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # common: EphemerisCommonContentDepB + ret += EphemerisCommonContentDepB._payload_size() + # tgd: double + ret += 8 + # c_rs: double + ret += 8 + # c_rc: double + ret += 8 + # c_uc: double + ret += 8 + # c_us: double + ret += 8 + # c_ic: double + ret += 8 + # c_is: double + ret += 8 + # dn: double + ret += 8 + # m0: double + ret += 8 + # ecc: double + ret += 8 + # sqrta: double + ret += 8 + # omega0: double + ret += 8 + # omegadot: double + ret += 8 + # w: double + ret += 8 + # inc: double + ret += 8 + # inc_dot: double + ret += 8 + # af0: double + ret += 8 + # af1: double + ret += 8 + # af2: double + ret += 8 + # toc: GPSTimeSec + ret += GPSTimeSec._payload_size() + # iode: u8 + ret += 1 + # iodc: u16 + ret += 2 + return ret SBP_MSG_EPHEMERIS_GPS = 0x008A class MsgEphemerisGPS(SBP): @@ -869,101 +992,54 @@ class MsgEphemerisGPS(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__common, offset, length) = offset, EphemerisCommonContent.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tgd, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rs, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rc, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_uc, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_us, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_ic, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_is, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af0, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af1, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af2, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toc, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iode, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iodc, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'common' : __common, - 'tgd' : __tgd, - 'c_rs' : __c_rs, - 'c_rc' : __c_rc, - 'c_uc' : __c_uc, - 'c_us' : __c_us, - 'c_ic' : __c_ic, - 'c_is' : __c_is, - 'dn' : __dn, - 'm0' : __m0, - 'ecc' : __ecc, - 'sqrta' : __sqrta, - 'omega0' : __omega0, - 'omegadot' : __omegadot, - 'w' : __w, - 'inc' : __inc, - 'inc_dot' : __inc_dot, - 'af0' : __af0, - 'af1' : __af1, - 'af2' : __af2, - 'toc' : __toc, - 'iode' : __iode, - 'iodc' : __iodc, - }, offset, length + ret = {} + (__common, offset, length) = EphemerisCommonContent.parse_members(buf, offset, length) + ret['common'] = __common + (__tgd, offset, length) = get_f32(buf, offset, length) + ret['tgd'] = judicious_round(nb.f4(__tgd)) if SBP.judicious_rounding else __tgd + (__c_rs, offset, length) = get_f32(buf, offset, length) + ret['c_rs'] = judicious_round(nb.f4(__c_rs)) if SBP.judicious_rounding else __c_rs + (__c_rc, offset, length) = get_f32(buf, offset, length) + ret['c_rc'] = judicious_round(nb.f4(__c_rc)) if SBP.judicious_rounding else __c_rc + (__c_uc, offset, length) = get_f32(buf, offset, length) + ret['c_uc'] = judicious_round(nb.f4(__c_uc)) if SBP.judicious_rounding else __c_uc + (__c_us, offset, length) = get_f32(buf, offset, length) + ret['c_us'] = judicious_round(nb.f4(__c_us)) if SBP.judicious_rounding else __c_us + (__c_ic, offset, length) = get_f32(buf, offset, length) + ret['c_ic'] = judicious_round(nb.f4(__c_ic)) if SBP.judicious_rounding else __c_ic + (__c_is, offset, length) = get_f32(buf, offset, length) + ret['c_is'] = judicious_round(nb.f4(__c_is)) if SBP.judicious_rounding else __c_is + (__dn, offset, length) = get_f64(buf, offset, length) + ret['dn'] = __dn + (__m0, offset, length) = get_f64(buf, offset, length) + ret['m0'] = __m0 + (__ecc, offset, length) = get_f64(buf, offset, length) + ret['ecc'] = __ecc + (__sqrta, offset, length) = get_f64(buf, offset, length) + ret['sqrta'] = __sqrta + (__omega0, offset, length) = get_f64(buf, offset, length) + ret['omega0'] = __omega0 + (__omegadot, offset, length) = get_f64(buf, offset, length) + ret['omegadot'] = __omegadot + (__w, offset, length) = get_f64(buf, offset, length) + ret['w'] = __w + (__inc, offset, length) = get_f64(buf, offset, length) + ret['inc'] = __inc + (__inc_dot, offset, length) = get_f64(buf, offset, length) + ret['inc_dot'] = __inc_dot + (__af0, offset, length) = get_f32(buf, offset, length) + ret['af0'] = judicious_round(nb.f4(__af0)) if SBP.judicious_rounding else __af0 + (__af1, offset, length) = get_f32(buf, offset, length) + ret['af1'] = judicious_round(nb.f4(__af1)) if SBP.judicious_rounding else __af1 + (__af2, offset, length) = get_f32(buf, offset, length) + ret['af2'] = judicious_round(nb.f4(__af2)) if SBP.judicious_rounding else __af2 + (__toc, offset, length) = GPSTimeSec.parse_members(buf, offset, length) + ret['toc'] = __toc + (__iode, offset, length) = get_u8(buf, offset, length) + ret['iode'] = __iode + (__iodc, offset, length) = get_u16(buf, offset, length) + ret['iodc'] = __iodc + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -993,6 +1069,57 @@ def _unpack_members(self, buf, offset, length): self.iode = res['iode'] self.iodc = res['iodc'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # common: EphemerisCommonContent + ret += EphemerisCommonContent._payload_size() + # tgd: float + ret += 4 + # c_rs: float + ret += 4 + # c_rc: float + ret += 4 + # c_uc: float + ret += 4 + # c_us: float + ret += 4 + # c_ic: float + ret += 4 + # c_is: float + ret += 4 + # dn: double + ret += 8 + # m0: double + ret += 8 + # ecc: double + ret += 8 + # sqrta: double + ret += 8 + # omega0: double + ret += 8 + # omegadot: double + ret += 8 + # w: double + ret += 8 + # inc: double + ret += 8 + # inc_dot: double + ret += 8 + # af0: float + ret += 4 + # af1: float + ret += 4 + # af2: float + ret += 4 + # toc: GPSTimeSec + ret += GPSTimeSec._payload_size() + # iode: u8 + ret += 1 + # iodc: u16 + ret += 2 + return ret SBP_MSG_EPHEMERIS_BDS = 0x0089 class MsgEphemerisBds(SBP): @@ -1037,105 +1164,56 @@ class MsgEphemerisBds(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__common, offset, length) = offset, EphemerisCommonContent.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tgd1, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tgd2, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rs, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rc, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_uc, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_us, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_ic, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_is, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af1, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af2, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toc, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iode, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iodc, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'common' : __common, - 'tgd1' : __tgd1, - 'tgd2' : __tgd2, - 'c_rs' : __c_rs, - 'c_rc' : __c_rc, - 'c_uc' : __c_uc, - 'c_us' : __c_us, - 'c_ic' : __c_ic, - 'c_is' : __c_is, - 'dn' : __dn, - 'm0' : __m0, - 'ecc' : __ecc, - 'sqrta' : __sqrta, - 'omega0' : __omega0, - 'omegadot' : __omegadot, - 'w' : __w, - 'inc' : __inc, - 'inc_dot' : __inc_dot, - 'af0' : __af0, - 'af1' : __af1, - 'af2' : __af2, - 'toc' : __toc, - 'iode' : __iode, - 'iodc' : __iodc, - }, offset, length + ret = {} + (__common, offset, length) = EphemerisCommonContent.parse_members(buf, offset, length) + ret['common'] = __common + (__tgd1, offset, length) = get_f32(buf, offset, length) + ret['tgd1'] = judicious_round(nb.f4(__tgd1)) if SBP.judicious_rounding else __tgd1 + (__tgd2, offset, length) = get_f32(buf, offset, length) + ret['tgd2'] = judicious_round(nb.f4(__tgd2)) if SBP.judicious_rounding else __tgd2 + (__c_rs, offset, length) = get_f32(buf, offset, length) + ret['c_rs'] = judicious_round(nb.f4(__c_rs)) if SBP.judicious_rounding else __c_rs + (__c_rc, offset, length) = get_f32(buf, offset, length) + ret['c_rc'] = judicious_round(nb.f4(__c_rc)) if SBP.judicious_rounding else __c_rc + (__c_uc, offset, length) = get_f32(buf, offset, length) + ret['c_uc'] = judicious_round(nb.f4(__c_uc)) if SBP.judicious_rounding else __c_uc + (__c_us, offset, length) = get_f32(buf, offset, length) + ret['c_us'] = judicious_round(nb.f4(__c_us)) if SBP.judicious_rounding else __c_us + (__c_ic, offset, length) = get_f32(buf, offset, length) + ret['c_ic'] = judicious_round(nb.f4(__c_ic)) if SBP.judicious_rounding else __c_ic + (__c_is, offset, length) = get_f32(buf, offset, length) + ret['c_is'] = judicious_round(nb.f4(__c_is)) if SBP.judicious_rounding else __c_is + (__dn, offset, length) = get_f64(buf, offset, length) + ret['dn'] = __dn + (__m0, offset, length) = get_f64(buf, offset, length) + ret['m0'] = __m0 + (__ecc, offset, length) = get_f64(buf, offset, length) + ret['ecc'] = __ecc + (__sqrta, offset, length) = get_f64(buf, offset, length) + ret['sqrta'] = __sqrta + (__omega0, offset, length) = get_f64(buf, offset, length) + ret['omega0'] = __omega0 + (__omegadot, offset, length) = get_f64(buf, offset, length) + ret['omegadot'] = __omegadot + (__w, offset, length) = get_f64(buf, offset, length) + ret['w'] = __w + (__inc, offset, length) = get_f64(buf, offset, length) + ret['inc'] = __inc + (__inc_dot, offset, length) = get_f64(buf, offset, length) + ret['inc_dot'] = __inc_dot + (__af0, offset, length) = get_f64(buf, offset, length) + ret['af0'] = __af0 + (__af1, offset, length) = get_f32(buf, offset, length) + ret['af1'] = judicious_round(nb.f4(__af1)) if SBP.judicious_rounding else __af1 + (__af2, offset, length) = get_f32(buf, offset, length) + ret['af2'] = judicious_round(nb.f4(__af2)) if SBP.judicious_rounding else __af2 + (__toc, offset, length) = GPSTimeSec.parse_members(buf, offset, length) + ret['toc'] = __toc + (__iode, offset, length) = get_u8(buf, offset, length) + ret['iode'] = __iode + (__iodc, offset, length) = get_u16(buf, offset, length) + ret['iodc'] = __iodc + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1166,6 +1244,59 @@ def _unpack_members(self, buf, offset, length): self.iode = res['iode'] self.iodc = res['iodc'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # common: EphemerisCommonContent + ret += EphemerisCommonContent._payload_size() + # tgd1: float + ret += 4 + # tgd2: float + ret += 4 + # c_rs: float + ret += 4 + # c_rc: float + ret += 4 + # c_uc: float + ret += 4 + # c_us: float + ret += 4 + # c_ic: float + ret += 4 + # c_is: float + ret += 4 + # dn: double + ret += 8 + # m0: double + ret += 8 + # ecc: double + ret += 8 + # sqrta: double + ret += 8 + # omega0: double + ret += 8 + # omegadot: double + ret += 8 + # w: double + ret += 8 + # inc: double + ret += 8 + # inc_dot: double + ret += 8 + # af0: double + ret += 8 + # af1: float + ret += 4 + # af2: float + ret += 4 + # toc: GPSTimeSec + ret += GPSTimeSec._payload_size() + # iode: u8 + ret += 1 + # iodc: u16 + ret += 2 + return ret SBP_MSG_EPHEMERIS_GAL = 0x0095 class MsgEphemerisGal(SBP): @@ -1210,105 +1341,56 @@ class MsgEphemerisGal(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__common, offset, length) = offset, EphemerisCommonContent.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__bgd_e1e5a, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__bgd_e1e5b, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rs, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rc, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_uc, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_us, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_ic, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_is, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af2, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toc, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iode, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iodc, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'common' : __common, - 'bgd_e1e5a' : __bgd_e1e5a, - 'bgd_e1e5b' : __bgd_e1e5b, - 'c_rs' : __c_rs, - 'c_rc' : __c_rc, - 'c_uc' : __c_uc, - 'c_us' : __c_us, - 'c_ic' : __c_ic, - 'c_is' : __c_is, - 'dn' : __dn, - 'm0' : __m0, - 'ecc' : __ecc, - 'sqrta' : __sqrta, - 'omega0' : __omega0, - 'omegadot' : __omegadot, - 'w' : __w, - 'inc' : __inc, - 'inc_dot' : __inc_dot, - 'af0' : __af0, - 'af1' : __af1, - 'af2' : __af2, - 'toc' : __toc, - 'iode' : __iode, - 'iodc' : __iodc, - }, offset, length + ret = {} + (__common, offset, length) = EphemerisCommonContent.parse_members(buf, offset, length) + ret['common'] = __common + (__bgd_e1e5a, offset, length) = get_f32(buf, offset, length) + ret['bgd_e1e5a'] = judicious_round(nb.f4(__bgd_e1e5a)) if SBP.judicious_rounding else __bgd_e1e5a + (__bgd_e1e5b, offset, length) = get_f32(buf, offset, length) + ret['bgd_e1e5b'] = judicious_round(nb.f4(__bgd_e1e5b)) if SBP.judicious_rounding else __bgd_e1e5b + (__c_rs, offset, length) = get_f32(buf, offset, length) + ret['c_rs'] = judicious_round(nb.f4(__c_rs)) if SBP.judicious_rounding else __c_rs + (__c_rc, offset, length) = get_f32(buf, offset, length) + ret['c_rc'] = judicious_round(nb.f4(__c_rc)) if SBP.judicious_rounding else __c_rc + (__c_uc, offset, length) = get_f32(buf, offset, length) + ret['c_uc'] = judicious_round(nb.f4(__c_uc)) if SBP.judicious_rounding else __c_uc + (__c_us, offset, length) = get_f32(buf, offset, length) + ret['c_us'] = judicious_round(nb.f4(__c_us)) if SBP.judicious_rounding else __c_us + (__c_ic, offset, length) = get_f32(buf, offset, length) + ret['c_ic'] = judicious_round(nb.f4(__c_ic)) if SBP.judicious_rounding else __c_ic + (__c_is, offset, length) = get_f32(buf, offset, length) + ret['c_is'] = judicious_round(nb.f4(__c_is)) if SBP.judicious_rounding else __c_is + (__dn, offset, length) = get_f64(buf, offset, length) + ret['dn'] = __dn + (__m0, offset, length) = get_f64(buf, offset, length) + ret['m0'] = __m0 + (__ecc, offset, length) = get_f64(buf, offset, length) + ret['ecc'] = __ecc + (__sqrta, offset, length) = get_f64(buf, offset, length) + ret['sqrta'] = __sqrta + (__omega0, offset, length) = get_f64(buf, offset, length) + ret['omega0'] = __omega0 + (__omegadot, offset, length) = get_f64(buf, offset, length) + ret['omegadot'] = __omegadot + (__w, offset, length) = get_f64(buf, offset, length) + ret['w'] = __w + (__inc, offset, length) = get_f64(buf, offset, length) + ret['inc'] = __inc + (__inc_dot, offset, length) = get_f64(buf, offset, length) + ret['inc_dot'] = __inc_dot + (__af0, offset, length) = get_f64(buf, offset, length) + ret['af0'] = __af0 + (__af1, offset, length) = get_f64(buf, offset, length) + ret['af1'] = __af1 + (__af2, offset, length) = get_f32(buf, offset, length) + ret['af2'] = judicious_round(nb.f4(__af2)) if SBP.judicious_rounding else __af2 + (__toc, offset, length) = GPSTimeSec.parse_members(buf, offset, length) + ret['toc'] = __toc + (__iode, offset, length) = get_u16(buf, offset, length) + ret['iode'] = __iode + (__iodc, offset, length) = get_u16(buf, offset, length) + ret['iodc'] = __iodc + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1339,6 +1421,59 @@ def _unpack_members(self, buf, offset, length): self.iode = res['iode'] self.iodc = res['iodc'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # common: EphemerisCommonContent + ret += EphemerisCommonContent._payload_size() + # bgd_e1e5a: float + ret += 4 + # bgd_e1e5b: float + ret += 4 + # c_rs: float + ret += 4 + # c_rc: float + ret += 4 + # c_uc: float + ret += 4 + # c_us: float + ret += 4 + # c_ic: float + ret += 4 + # c_is: float + ret += 4 + # dn: double + ret += 8 + # m0: double + ret += 8 + # ecc: double + ret += 8 + # sqrta: double + ret += 8 + # omega0: double + ret += 8 + # omegadot: double + ret += 8 + # w: double + ret += 8 + # inc: double + ret += 8 + # inc_dot: double + ret += 8 + # af0: double + ret += 8 + # af1: double + ret += 8 + # af2: float + ret += 4 + # toc: GPSTimeSec + ret += GPSTimeSec._payload_size() + # iode: u16 + ret += 2 + # iodc: u16 + ret += 2 + return ret SBP_MSG_EPHEMERIS_SBAS_DEP_A = 0x0082 class MsgEphemerisSbasDepA(SBP): @@ -1360,33 +1495,20 @@ class MsgEphemerisSbasDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__common, offset, length) = offset, EphemerisCommonContentDepA.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pos, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__vel, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__acc, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__a_gf0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__a_gf1, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'common' : __common, - 'pos' : __pos, - 'vel' : __vel, - 'acc' : __acc, - 'a_gf0' : __a_gf0, - 'a_gf1' : __a_gf1, - }, offset, length + ret = {} + (__common, offset, length) = EphemerisCommonContentDepA.parse_members(buf, offset, length) + ret['common'] = __common + (__pos, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['pos'] = __pos + (__vel, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['vel'] = __vel + (__acc, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['acc'] = __acc + (__a_gf0, offset, length) = get_f64(buf, offset, length) + ret['a_gf0'] = __a_gf0 + (__a_gf1, offset, length) = get_f64(buf, offset, length) + ret['a_gf1'] = __a_gf1 + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1399,6 +1521,23 @@ def _unpack_members(self, buf, offset, length): self.a_gf0 = res['a_gf0'] self.a_gf1 = res['a_gf1'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # common: EphemerisCommonContentDepA + ret += EphemerisCommonContentDepA._payload_size() + # pos: array of double + ret += 8 * 3 + # vel: array of double + ret += 8 * 3 + # acc: array of double + ret += 8 * 3 + # a_gf0: double + ret += 8 + # a_gf1: double + ret += 8 + return ret SBP_MSG_EPHEMERIS_GLO_DEP_A = 0x0083 class MsgEphemerisGloDepA(SBP): @@ -1426,33 +1565,20 @@ class MsgEphemerisGloDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__common, offset, length) = offset, EphemerisCommonContentDepA.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__gamma, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tau, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pos, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__vel, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__acc, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'common' : __common, - 'gamma' : __gamma, - 'tau' : __tau, - 'pos' : __pos, - 'vel' : __vel, - 'acc' : __acc, - }, offset, length + ret = {} + (__common, offset, length) = EphemerisCommonContentDepA.parse_members(buf, offset, length) + ret['common'] = __common + (__gamma, offset, length) = get_f64(buf, offset, length) + ret['gamma'] = __gamma + (__tau, offset, length) = get_f64(buf, offset, length) + ret['tau'] = __tau + (__pos, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['pos'] = __pos + (__vel, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['vel'] = __vel + (__acc, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['acc'] = __acc + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1465,6 +1591,23 @@ def _unpack_members(self, buf, offset, length): self.vel = res['vel'] self.acc = res['acc'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # common: EphemerisCommonContentDepA + ret += EphemerisCommonContentDepA._payload_size() + # gamma: double + ret += 8 + # tau: double + ret += 8 + # pos: array of double + ret += 8 * 3 + # vel: array of double + ret += 8 * 3 + # acc: array of double + ret += 8 * 3 + return ret SBP_MSG_EPHEMERIS_SBAS_DEP_B = 0x0084 class MsgEphemerisSbasDepB(SBP): @@ -1489,33 +1632,20 @@ class MsgEphemerisSbasDepB(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__common, offset, length) = offset, EphemerisCommonContentDepB.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pos, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__vel, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__acc, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__a_gf0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__a_gf1, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'common' : __common, - 'pos' : __pos, - 'vel' : __vel, - 'acc' : __acc, - 'a_gf0' : __a_gf0, - 'a_gf1' : __a_gf1, - }, offset, length + ret = {} + (__common, offset, length) = EphemerisCommonContentDepB.parse_members(buf, offset, length) + ret['common'] = __common + (__pos, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['pos'] = __pos + (__vel, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['vel'] = __vel + (__acc, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['acc'] = __acc + (__a_gf0, offset, length) = get_f64(buf, offset, length) + ret['a_gf0'] = __a_gf0 + (__a_gf1, offset, length) = get_f64(buf, offset, length) + ret['a_gf1'] = __a_gf1 + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1528,6 +1658,23 @@ def _unpack_members(self, buf, offset, length): self.a_gf0 = res['a_gf0'] self.a_gf1 = res['a_gf1'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # common: EphemerisCommonContentDepB + ret += EphemerisCommonContentDepB._payload_size() + # pos: array of double + ret += 8 * 3 + # vel: array of double + ret += 8 * 3 + # acc: array of double + ret += 8 * 3 + # a_gf0: double + ret += 8 + # a_gf1: double + ret += 8 + return ret SBP_MSG_EPHEMERIS_SBAS = 0x008C class MsgEphemerisSbas(SBP): @@ -1549,33 +1696,20 @@ class MsgEphemerisSbas(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__common, offset, length) = offset, EphemerisCommonContent.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pos, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__vel, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__acc, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__a_gf0, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__a_gf1, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'common' : __common, - 'pos' : __pos, - 'vel' : __vel, - 'acc' : __acc, - 'a_gf0' : __a_gf0, - 'a_gf1' : __a_gf1, - }, offset, length + ret = {} + (__common, offset, length) = EphemerisCommonContent.parse_members(buf, offset, length) + ret['common'] = __common + (__pos, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['pos'] = __pos + (__vel, offset, length) = get_fixed_array(get_f32, 3, 4, nb.f4 if SBP.judicious_rounding else None)(buf, offset, length) + ret['vel'] = __vel + (__acc, offset, length) = get_fixed_array(get_f32, 3, 4, nb.f4 if SBP.judicious_rounding else None)(buf, offset, length) + ret['acc'] = __acc + (__a_gf0, offset, length) = get_f32(buf, offset, length) + ret['a_gf0'] = judicious_round(nb.f4(__a_gf0)) if SBP.judicious_rounding else __a_gf0 + (__a_gf1, offset, length) = get_f32(buf, offset, length) + ret['a_gf1'] = judicious_round(nb.f4(__a_gf1)) if SBP.judicious_rounding else __a_gf1 + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1588,6 +1722,23 @@ def _unpack_members(self, buf, offset, length): self.a_gf0 = res['a_gf0'] self.a_gf1 = res['a_gf1'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # common: EphemerisCommonContent + ret += EphemerisCommonContent._payload_size() + # pos: array of double + ret += 8 * 3 + # vel: array of float + ret += 4 * 3 + # acc: array of float + ret += 4 * 3 + # a_gf0: float + ret += 4 + # a_gf1: float + ret += 4 + return ret SBP_MSG_EPHEMERIS_GLO_DEP_B = 0x0085 class MsgEphemerisGloDepB(SBP): @@ -1615,33 +1766,20 @@ class MsgEphemerisGloDepB(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__common, offset, length) = offset, EphemerisCommonContentDepB.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__gamma, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tau, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pos, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__vel, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__acc, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'common' : __common, - 'gamma' : __gamma, - 'tau' : __tau, - 'pos' : __pos, - 'vel' : __vel, - 'acc' : __acc, - }, offset, length + ret = {} + (__common, offset, length) = EphemerisCommonContentDepB.parse_members(buf, offset, length) + ret['common'] = __common + (__gamma, offset, length) = get_f64(buf, offset, length) + ret['gamma'] = __gamma + (__tau, offset, length) = get_f64(buf, offset, length) + ret['tau'] = __tau + (__pos, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['pos'] = __pos + (__vel, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['vel'] = __vel + (__acc, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['acc'] = __acc + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1654,6 +1792,23 @@ def _unpack_members(self, buf, offset, length): self.vel = res['vel'] self.acc = res['acc'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # common: EphemerisCommonContentDepB + ret += EphemerisCommonContentDepB._payload_size() + # gamma: double + ret += 8 + # tau: double + ret += 8 + # pos: array of double + ret += 8 * 3 + # vel: array of double + ret += 8 * 3 + # acc: array of double + ret += 8 * 3 + return ret SBP_MSG_EPHEMERIS_GLO_DEP_C = 0x0087 class MsgEphemerisGloDepC(SBP): @@ -1683,41 +1838,24 @@ class MsgEphemerisGloDepC(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__common, offset, length) = offset, EphemerisCommonContentDepB.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__gamma, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tau, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__d_tau, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pos, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__vel, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__acc, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__fcn, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'common' : __common, - 'gamma' : __gamma, - 'tau' : __tau, - 'd_tau' : __d_tau, - 'pos' : __pos, - 'vel' : __vel, - 'acc' : __acc, - 'fcn' : __fcn, - }, offset, length + ret = {} + (__common, offset, length) = EphemerisCommonContentDepB.parse_members(buf, offset, length) + ret['common'] = __common + (__gamma, offset, length) = get_f64(buf, offset, length) + ret['gamma'] = __gamma + (__tau, offset, length) = get_f64(buf, offset, length) + ret['tau'] = __tau + (__d_tau, offset, length) = get_f64(buf, offset, length) + ret['d_tau'] = __d_tau + (__pos, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['pos'] = __pos + (__vel, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['vel'] = __vel + (__acc, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['acc'] = __acc + (__fcn, offset, length) = get_u8(buf, offset, length) + ret['fcn'] = __fcn + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1732,6 +1870,27 @@ def _unpack_members(self, buf, offset, length): self.acc = res['acc'] self.fcn = res['fcn'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # common: EphemerisCommonContentDepB + ret += EphemerisCommonContentDepB._payload_size() + # gamma: double + ret += 8 + # tau: double + ret += 8 + # d_tau: double + ret += 8 + # pos: array of double + ret += 8 * 3 + # vel: array of double + ret += 8 * 3 + # acc: array of double + ret += 8 * 3 + # fcn: u8 + ret += 1 + return ret SBP_MSG_EPHEMERIS_GLO_DEP_D = 0x0088 class MsgEphemerisGloDepD(SBP): @@ -1759,45 +1918,26 @@ class MsgEphemerisGloDepD(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__common, offset, length) = offset, EphemerisCommonContentDepB.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__gamma, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tau, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__d_tau, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pos, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__vel, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__acc, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__fcn, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iod, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'common' : __common, - 'gamma' : __gamma, - 'tau' : __tau, - 'd_tau' : __d_tau, - 'pos' : __pos, - 'vel' : __vel, - 'acc' : __acc, - 'fcn' : __fcn, - 'iod' : __iod, - }, offset, length + ret = {} + (__common, offset, length) = EphemerisCommonContentDepB.parse_members(buf, offset, length) + ret['common'] = __common + (__gamma, offset, length) = get_f64(buf, offset, length) + ret['gamma'] = __gamma + (__tau, offset, length) = get_f64(buf, offset, length) + ret['tau'] = __tau + (__d_tau, offset, length) = get_f64(buf, offset, length) + ret['d_tau'] = __d_tau + (__pos, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['pos'] = __pos + (__vel, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['vel'] = __vel + (__acc, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['acc'] = __acc + (__fcn, offset, length) = get_u8(buf, offset, length) + ret['fcn'] = __fcn + (__iod, offset, length) = get_u8(buf, offset, length) + ret['iod'] = __iod + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1813,6 +1953,29 @@ def _unpack_members(self, buf, offset, length): self.fcn = res['fcn'] self.iod = res['iod'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # common: EphemerisCommonContentDepB + ret += EphemerisCommonContentDepB._payload_size() + # gamma: double + ret += 8 + # tau: double + ret += 8 + # d_tau: double + ret += 8 + # pos: array of double + ret += 8 * 3 + # vel: array of double + ret += 8 * 3 + # acc: array of double + ret += 8 * 3 + # fcn: u8 + ret += 1 + # iod: u8 + ret += 1 + return ret SBP_MSG_EPHEMERIS_GLO = 0x008B class MsgEphemerisGlo(SBP): @@ -1843,45 +2006,26 @@ class MsgEphemerisGlo(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__common, offset, length) = offset, EphemerisCommonContent.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__gamma, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tau, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__d_tau, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pos, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__vel, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__acc, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__fcn, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iod, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'common' : __common, - 'gamma' : __gamma, - 'tau' : __tau, - 'd_tau' : __d_tau, - 'pos' : __pos, - 'vel' : __vel, - 'acc' : __acc, - 'fcn' : __fcn, - 'iod' : __iod, - }, offset, length + ret = {} + (__common, offset, length) = EphemerisCommonContent.parse_members(buf, offset, length) + ret['common'] = __common + (__gamma, offset, length) = get_f32(buf, offset, length) + ret['gamma'] = judicious_round(nb.f4(__gamma)) if SBP.judicious_rounding else __gamma + (__tau, offset, length) = get_f32(buf, offset, length) + ret['tau'] = judicious_round(nb.f4(__tau)) if SBP.judicious_rounding else __tau + (__d_tau, offset, length) = get_f32(buf, offset, length) + ret['d_tau'] = judicious_round(nb.f4(__d_tau)) if SBP.judicious_rounding else __d_tau + (__pos, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['pos'] = __pos + (__vel, offset, length) = get_fixed_array(get_f64, 3, 8)(buf, offset, length) + ret['vel'] = __vel + (__acc, offset, length) = get_fixed_array(get_f32, 3, 4, nb.f4 if SBP.judicious_rounding else None)(buf, offset, length) + ret['acc'] = __acc + (__fcn, offset, length) = get_u8(buf, offset, length) + ret['fcn'] = __fcn + (__iod, offset, length) = get_u8(buf, offset, length) + ret['iod'] = __iod + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1897,6 +2041,29 @@ def _unpack_members(self, buf, offset, length): self.fcn = res['fcn'] self.iod = res['iod'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # common: EphemerisCommonContent + ret += EphemerisCommonContent._payload_size() + # gamma: float + ret += 4 + # tau: float + ret += 4 + # d_tau: float + ret += 4 + # pos: array of double + ret += 8 * 3 + # vel: array of double + ret += 8 * 3 + # acc: array of float + ret += 4 * 3 + # fcn: u8 + ret += 1 + # iod: u8 + ret += 1 + return ret SBP_MSG_EPHEMERIS_DEP_D = 0x0080 class MsgEphemerisDepD(SBP): @@ -1947,125 +2114,66 @@ class MsgEphemerisDepD(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tgd, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rs, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_uc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_us, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_ic, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_is, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af2, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toe_tow, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toe_wn, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toc_tow, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toc_wn, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__healthy, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iode, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iodc, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__reserved, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tgd' : __tgd, - 'c_rs' : __c_rs, - 'c_rc' : __c_rc, - 'c_uc' : __c_uc, - 'c_us' : __c_us, - 'c_ic' : __c_ic, - 'c_is' : __c_is, - 'dn' : __dn, - 'm0' : __m0, - 'ecc' : __ecc, - 'sqrta' : __sqrta, - 'omega0' : __omega0, - 'omegadot' : __omegadot, - 'w' : __w, - 'inc' : __inc, - 'inc_dot' : __inc_dot, - 'af0' : __af0, - 'af1' : __af1, - 'af2' : __af2, - 'toe_tow' : __toe_tow, - 'toe_wn' : __toe_wn, - 'toc_tow' : __toc_tow, - 'toc_wn' : __toc_wn, - 'valid' : __valid, - 'healthy' : __healthy, - 'sid' : __sid, - 'iode' : __iode, - 'iodc' : __iodc, - 'reserved' : __reserved, - }, offset, length + ret = {} + (__tgd, offset, length) = get_f64(buf, offset, length) + ret['tgd'] = __tgd + (__c_rs, offset, length) = get_f64(buf, offset, length) + ret['c_rs'] = __c_rs + (__c_rc, offset, length) = get_f64(buf, offset, length) + ret['c_rc'] = __c_rc + (__c_uc, offset, length) = get_f64(buf, offset, length) + ret['c_uc'] = __c_uc + (__c_us, offset, length) = get_f64(buf, offset, length) + ret['c_us'] = __c_us + (__c_ic, offset, length) = get_f64(buf, offset, length) + ret['c_ic'] = __c_ic + (__c_is, offset, length) = get_f64(buf, offset, length) + ret['c_is'] = __c_is + (__dn, offset, length) = get_f64(buf, offset, length) + ret['dn'] = __dn + (__m0, offset, length) = get_f64(buf, offset, length) + ret['m0'] = __m0 + (__ecc, offset, length) = get_f64(buf, offset, length) + ret['ecc'] = __ecc + (__sqrta, offset, length) = get_f64(buf, offset, length) + ret['sqrta'] = __sqrta + (__omega0, offset, length) = get_f64(buf, offset, length) + ret['omega0'] = __omega0 + (__omegadot, offset, length) = get_f64(buf, offset, length) + ret['omegadot'] = __omegadot + (__w, offset, length) = get_f64(buf, offset, length) + ret['w'] = __w + (__inc, offset, length) = get_f64(buf, offset, length) + ret['inc'] = __inc + (__inc_dot, offset, length) = get_f64(buf, offset, length) + ret['inc_dot'] = __inc_dot + (__af0, offset, length) = get_f64(buf, offset, length) + ret['af0'] = __af0 + (__af1, offset, length) = get_f64(buf, offset, length) + ret['af1'] = __af1 + (__af2, offset, length) = get_f64(buf, offset, length) + ret['af2'] = __af2 + (__toe_tow, offset, length) = get_f64(buf, offset, length) + ret['toe_tow'] = __toe_tow + (__toe_wn, offset, length) = get_u16(buf, offset, length) + ret['toe_wn'] = __toe_wn + (__toc_tow, offset, length) = get_f64(buf, offset, length) + ret['toc_tow'] = __toc_tow + (__toc_wn, offset, length) = get_u16(buf, offset, length) + ret['toc_wn'] = __toc_wn + (__valid, offset, length) = get_u8(buf, offset, length) + ret['valid'] = __valid + (__healthy, offset, length) = get_u8(buf, offset, length) + ret['healthy'] = __healthy + (__sid, offset, length) = GnssSignalDep.parse_members(buf, offset, length) + ret['sid'] = __sid + (__iode, offset, length) = get_u8(buf, offset, length) + ret['iode'] = __iode + (__iodc, offset, length) = get_u16(buf, offset, length) + ret['iodc'] = __iodc + (__reserved, offset, length) = get_u32(buf, offset, length) + ret['reserved'] = __reserved + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -2101,6 +2209,69 @@ def _unpack_members(self, buf, offset, length): self.iodc = res['iodc'] self.reserved = res['reserved'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tgd: double + ret += 8 + # c_rs: double + ret += 8 + # c_rc: double + ret += 8 + # c_uc: double + ret += 8 + # c_us: double + ret += 8 + # c_ic: double + ret += 8 + # c_is: double + ret += 8 + # dn: double + ret += 8 + # m0: double + ret += 8 + # ecc: double + ret += 8 + # sqrta: double + ret += 8 + # omega0: double + ret += 8 + # omegadot: double + ret += 8 + # w: double + ret += 8 + # inc: double + ret += 8 + # inc_dot: double + ret += 8 + # af0: double + ret += 8 + # af1: double + ret += 8 + # af2: double + ret += 8 + # toe_tow: double + ret += 8 + # toe_wn: u16 + ret += 2 + # toc_tow: double + ret += 8 + # toc_wn: u16 + ret += 2 + # valid: u8 + ret += 1 + # healthy: u8 + ret += 1 + # sid: GnssSignalDep + ret += GnssSignalDep._payload_size() + # iode: u8 + ret += 1 + # iodc: u16 + ret += 2 + # reserved: u32 + ret += 4 + return ret SBP_MSG_EPHEMERIS_DEP_A = 0x001A class MsgEphemerisDepA(SBP): @@ -2143,113 +2314,60 @@ class MsgEphemerisDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tgd, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rs, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_uc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_us, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_ic, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_is, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af2, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toe_tow, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toe_wn, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toc_tow, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toc_wn, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__healthy, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__prn, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tgd' : __tgd, - 'c_rs' : __c_rs, - 'c_rc' : __c_rc, - 'c_uc' : __c_uc, - 'c_us' : __c_us, - 'c_ic' : __c_ic, - 'c_is' : __c_is, - 'dn' : __dn, - 'm0' : __m0, - 'ecc' : __ecc, - 'sqrta' : __sqrta, - 'omega0' : __omega0, - 'omegadot' : __omegadot, - 'w' : __w, - 'inc' : __inc, - 'inc_dot' : __inc_dot, - 'af0' : __af0, - 'af1' : __af1, - 'af2' : __af2, - 'toe_tow' : __toe_tow, - 'toe_wn' : __toe_wn, - 'toc_tow' : __toc_tow, - 'toc_wn' : __toc_wn, - 'valid' : __valid, - 'healthy' : __healthy, - 'prn' : __prn, - }, offset, length + ret = {} + (__tgd, offset, length) = get_f64(buf, offset, length) + ret['tgd'] = __tgd + (__c_rs, offset, length) = get_f64(buf, offset, length) + ret['c_rs'] = __c_rs + (__c_rc, offset, length) = get_f64(buf, offset, length) + ret['c_rc'] = __c_rc + (__c_uc, offset, length) = get_f64(buf, offset, length) + ret['c_uc'] = __c_uc + (__c_us, offset, length) = get_f64(buf, offset, length) + ret['c_us'] = __c_us + (__c_ic, offset, length) = get_f64(buf, offset, length) + ret['c_ic'] = __c_ic + (__c_is, offset, length) = get_f64(buf, offset, length) + ret['c_is'] = __c_is + (__dn, offset, length) = get_f64(buf, offset, length) + ret['dn'] = __dn + (__m0, offset, length) = get_f64(buf, offset, length) + ret['m0'] = __m0 + (__ecc, offset, length) = get_f64(buf, offset, length) + ret['ecc'] = __ecc + (__sqrta, offset, length) = get_f64(buf, offset, length) + ret['sqrta'] = __sqrta + (__omega0, offset, length) = get_f64(buf, offset, length) + ret['omega0'] = __omega0 + (__omegadot, offset, length) = get_f64(buf, offset, length) + ret['omegadot'] = __omegadot + (__w, offset, length) = get_f64(buf, offset, length) + ret['w'] = __w + (__inc, offset, length) = get_f64(buf, offset, length) + ret['inc'] = __inc + (__inc_dot, offset, length) = get_f64(buf, offset, length) + ret['inc_dot'] = __inc_dot + (__af0, offset, length) = get_f64(buf, offset, length) + ret['af0'] = __af0 + (__af1, offset, length) = get_f64(buf, offset, length) + ret['af1'] = __af1 + (__af2, offset, length) = get_f64(buf, offset, length) + ret['af2'] = __af2 + (__toe_tow, offset, length) = get_f64(buf, offset, length) + ret['toe_tow'] = __toe_tow + (__toe_wn, offset, length) = get_u16(buf, offset, length) + ret['toe_wn'] = __toe_wn + (__toc_tow, offset, length) = get_f64(buf, offset, length) + ret['toc_tow'] = __toc_tow + (__toc_wn, offset, length) = get_u16(buf, offset, length) + ret['toc_wn'] = __toc_wn + (__valid, offset, length) = get_u8(buf, offset, length) + ret['valid'] = __valid + (__healthy, offset, length) = get_u8(buf, offset, length) + ret['healthy'] = __healthy + (__prn, offset, length) = get_u8(buf, offset, length) + ret['prn'] = __prn + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -2282,6 +2400,63 @@ def _unpack_members(self, buf, offset, length): self.healthy = res['healthy'] self.prn = res['prn'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tgd: double + ret += 8 + # c_rs: double + ret += 8 + # c_rc: double + ret += 8 + # c_uc: double + ret += 8 + # c_us: double + ret += 8 + # c_ic: double + ret += 8 + # c_is: double + ret += 8 + # dn: double + ret += 8 + # m0: double + ret += 8 + # ecc: double + ret += 8 + # sqrta: double + ret += 8 + # omega0: double + ret += 8 + # omegadot: double + ret += 8 + # w: double + ret += 8 + # inc: double + ret += 8 + # inc_dot: double + ret += 8 + # af0: double + ret += 8 + # af1: double + ret += 8 + # af2: double + ret += 8 + # toe_tow: double + ret += 8 + # toe_wn: u16 + ret += 2 + # toc_tow: double + ret += 8 + # toc_wn: u16 + ret += 2 + # valid: u8 + ret += 1 + # healthy: u8 + ret += 1 + # prn: u8 + ret += 1 + return ret SBP_MSG_EPHEMERIS_DEP_B = 0x0046 class MsgEphemerisDepB(SBP): @@ -2325,117 +2500,62 @@ class MsgEphemerisDepB(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tgd, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rs, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_uc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_us, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_ic, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_is, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af2, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toe_tow, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toe_wn, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toc_tow, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toc_wn, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__healthy, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__prn, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iode, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tgd' : __tgd, - 'c_rs' : __c_rs, - 'c_rc' : __c_rc, - 'c_uc' : __c_uc, - 'c_us' : __c_us, - 'c_ic' : __c_ic, - 'c_is' : __c_is, - 'dn' : __dn, - 'm0' : __m0, - 'ecc' : __ecc, - 'sqrta' : __sqrta, - 'omega0' : __omega0, - 'omegadot' : __omegadot, - 'w' : __w, - 'inc' : __inc, - 'inc_dot' : __inc_dot, - 'af0' : __af0, - 'af1' : __af1, - 'af2' : __af2, - 'toe_tow' : __toe_tow, - 'toe_wn' : __toe_wn, - 'toc_tow' : __toc_tow, - 'toc_wn' : __toc_wn, - 'valid' : __valid, - 'healthy' : __healthy, - 'prn' : __prn, - 'iode' : __iode, - }, offset, length + ret = {} + (__tgd, offset, length) = get_f64(buf, offset, length) + ret['tgd'] = __tgd + (__c_rs, offset, length) = get_f64(buf, offset, length) + ret['c_rs'] = __c_rs + (__c_rc, offset, length) = get_f64(buf, offset, length) + ret['c_rc'] = __c_rc + (__c_uc, offset, length) = get_f64(buf, offset, length) + ret['c_uc'] = __c_uc + (__c_us, offset, length) = get_f64(buf, offset, length) + ret['c_us'] = __c_us + (__c_ic, offset, length) = get_f64(buf, offset, length) + ret['c_ic'] = __c_ic + (__c_is, offset, length) = get_f64(buf, offset, length) + ret['c_is'] = __c_is + (__dn, offset, length) = get_f64(buf, offset, length) + ret['dn'] = __dn + (__m0, offset, length) = get_f64(buf, offset, length) + ret['m0'] = __m0 + (__ecc, offset, length) = get_f64(buf, offset, length) + ret['ecc'] = __ecc + (__sqrta, offset, length) = get_f64(buf, offset, length) + ret['sqrta'] = __sqrta + (__omega0, offset, length) = get_f64(buf, offset, length) + ret['omega0'] = __omega0 + (__omegadot, offset, length) = get_f64(buf, offset, length) + ret['omegadot'] = __omegadot + (__w, offset, length) = get_f64(buf, offset, length) + ret['w'] = __w + (__inc, offset, length) = get_f64(buf, offset, length) + ret['inc'] = __inc + (__inc_dot, offset, length) = get_f64(buf, offset, length) + ret['inc_dot'] = __inc_dot + (__af0, offset, length) = get_f64(buf, offset, length) + ret['af0'] = __af0 + (__af1, offset, length) = get_f64(buf, offset, length) + ret['af1'] = __af1 + (__af2, offset, length) = get_f64(buf, offset, length) + ret['af2'] = __af2 + (__toe_tow, offset, length) = get_f64(buf, offset, length) + ret['toe_tow'] = __toe_tow + (__toe_wn, offset, length) = get_u16(buf, offset, length) + ret['toe_wn'] = __toe_wn + (__toc_tow, offset, length) = get_f64(buf, offset, length) + ret['toc_tow'] = __toc_tow + (__toc_wn, offset, length) = get_u16(buf, offset, length) + ret['toc_wn'] = __toc_wn + (__valid, offset, length) = get_u8(buf, offset, length) + ret['valid'] = __valid + (__healthy, offset, length) = get_u8(buf, offset, length) + ret['healthy'] = __healthy + (__prn, offset, length) = get_u8(buf, offset, length) + ret['prn'] = __prn + (__iode, offset, length) = get_u8(buf, offset, length) + ret['iode'] = __iode + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -2469,6 +2589,65 @@ def _unpack_members(self, buf, offset, length): self.prn = res['prn'] self.iode = res['iode'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tgd: double + ret += 8 + # c_rs: double + ret += 8 + # c_rc: double + ret += 8 + # c_uc: double + ret += 8 + # c_us: double + ret += 8 + # c_ic: double + ret += 8 + # c_is: double + ret += 8 + # dn: double + ret += 8 + # m0: double + ret += 8 + # ecc: double + ret += 8 + # sqrta: double + ret += 8 + # omega0: double + ret += 8 + # omegadot: double + ret += 8 + # w: double + ret += 8 + # inc: double + ret += 8 + # inc_dot: double + ret += 8 + # af0: double + ret += 8 + # af1: double + ret += 8 + # af2: double + ret += 8 + # toe_tow: double + ret += 8 + # toe_wn: u16 + ret += 2 + # toc_tow: double + ret += 8 + # toc_wn: u16 + ret += 2 + # valid: u8 + ret += 1 + # healthy: u8 + ret += 1 + # prn: u8 + ret += 1 + # iode: u8 + ret += 1 + return ret SBP_MSG_EPHEMERIS_DEP_C = 0x0047 class MsgEphemerisDepC(SBP): @@ -2519,125 +2698,66 @@ class MsgEphemerisDepC(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tgd, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rs, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_rc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_uc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_us, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_ic, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c_is, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__dn, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc_dot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af2, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toe_tow, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toe_wn, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toc_tow, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toc_wn, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__healthy, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iode, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iodc, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__reserved, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tgd' : __tgd, - 'c_rs' : __c_rs, - 'c_rc' : __c_rc, - 'c_uc' : __c_uc, - 'c_us' : __c_us, - 'c_ic' : __c_ic, - 'c_is' : __c_is, - 'dn' : __dn, - 'm0' : __m0, - 'ecc' : __ecc, - 'sqrta' : __sqrta, - 'omega0' : __omega0, - 'omegadot' : __omegadot, - 'w' : __w, - 'inc' : __inc, - 'inc_dot' : __inc_dot, - 'af0' : __af0, - 'af1' : __af1, - 'af2' : __af2, - 'toe_tow' : __toe_tow, - 'toe_wn' : __toe_wn, - 'toc_tow' : __toc_tow, - 'toc_wn' : __toc_wn, - 'valid' : __valid, - 'healthy' : __healthy, - 'sid' : __sid, - 'iode' : __iode, - 'iodc' : __iodc, - 'reserved' : __reserved, - }, offset, length + ret = {} + (__tgd, offset, length) = get_f64(buf, offset, length) + ret['tgd'] = __tgd + (__c_rs, offset, length) = get_f64(buf, offset, length) + ret['c_rs'] = __c_rs + (__c_rc, offset, length) = get_f64(buf, offset, length) + ret['c_rc'] = __c_rc + (__c_uc, offset, length) = get_f64(buf, offset, length) + ret['c_uc'] = __c_uc + (__c_us, offset, length) = get_f64(buf, offset, length) + ret['c_us'] = __c_us + (__c_ic, offset, length) = get_f64(buf, offset, length) + ret['c_ic'] = __c_ic + (__c_is, offset, length) = get_f64(buf, offset, length) + ret['c_is'] = __c_is + (__dn, offset, length) = get_f64(buf, offset, length) + ret['dn'] = __dn + (__m0, offset, length) = get_f64(buf, offset, length) + ret['m0'] = __m0 + (__ecc, offset, length) = get_f64(buf, offset, length) + ret['ecc'] = __ecc + (__sqrta, offset, length) = get_f64(buf, offset, length) + ret['sqrta'] = __sqrta + (__omega0, offset, length) = get_f64(buf, offset, length) + ret['omega0'] = __omega0 + (__omegadot, offset, length) = get_f64(buf, offset, length) + ret['omegadot'] = __omegadot + (__w, offset, length) = get_f64(buf, offset, length) + ret['w'] = __w + (__inc, offset, length) = get_f64(buf, offset, length) + ret['inc'] = __inc + (__inc_dot, offset, length) = get_f64(buf, offset, length) + ret['inc_dot'] = __inc_dot + (__af0, offset, length) = get_f64(buf, offset, length) + ret['af0'] = __af0 + (__af1, offset, length) = get_f64(buf, offset, length) + ret['af1'] = __af1 + (__af2, offset, length) = get_f64(buf, offset, length) + ret['af2'] = __af2 + (__toe_tow, offset, length) = get_f64(buf, offset, length) + ret['toe_tow'] = __toe_tow + (__toe_wn, offset, length) = get_u16(buf, offset, length) + ret['toe_wn'] = __toe_wn + (__toc_tow, offset, length) = get_f64(buf, offset, length) + ret['toc_tow'] = __toc_tow + (__toc_wn, offset, length) = get_u16(buf, offset, length) + ret['toc_wn'] = __toc_wn + (__valid, offset, length) = get_u8(buf, offset, length) + ret['valid'] = __valid + (__healthy, offset, length) = get_u8(buf, offset, length) + ret['healthy'] = __healthy + (__sid, offset, length) = GnssSignalDep.parse_members(buf, offset, length) + ret['sid'] = __sid + (__iode, offset, length) = get_u8(buf, offset, length) + ret['iode'] = __iode + (__iodc, offset, length) = get_u16(buf, offset, length) + ret['iodc'] = __iodc + (__reserved, offset, length) = get_u32(buf, offset, length) + ret['reserved'] = __reserved + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -2673,6 +2793,69 @@ def _unpack_members(self, buf, offset, length): self.iodc = res['iodc'] self.reserved = res['reserved'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tgd: double + ret += 8 + # c_rs: double + ret += 8 + # c_rc: double + ret += 8 + # c_uc: double + ret += 8 + # c_us: double + ret += 8 + # c_ic: double + ret += 8 + # c_is: double + ret += 8 + # dn: double + ret += 8 + # m0: double + ret += 8 + # ecc: double + ret += 8 + # sqrta: double + ret += 8 + # omega0: double + ret += 8 + # omegadot: double + ret += 8 + # w: double + ret += 8 + # inc: double + ret += 8 + # inc_dot: double + ret += 8 + # af0: double + ret += 8 + # af1: double + ret += 8 + # af2: double + ret += 8 + # toe_tow: double + ret += 8 + # toe_wn: u16 + ret += 2 + # toc_tow: double + ret += 8 + # toc_wn: u16 + ret += 2 + # valid: u8 + ret += 1 + # healthy: u8 + ret += 1 + # sid: GnssSignalDep + ret += GnssSignalDep._payload_size() + # iode: u8 + ret += 1 + # iodc: u16 + ret += 2 + # reserved: u32 + ret += 4 + return ret class ObservationHeaderDep(object): """SBP class for message ObservationHeaderDep @@ -2690,17 +2873,12 @@ class ObservationHeaderDep(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__t, offset, length) = offset, GPSTimeDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_obs, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 't' : __t, - 'n_obs' : __n_obs, - }, offset, length + ret = {} + (__t, offset, length) = GPSTimeDep.parse_members(buf, offset, length) + ret['t'] = __t + (__n_obs, offset, length) = get_u8(buf, offset, length) + ret['n_obs'] = __n_obs + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -2709,6 +2887,15 @@ def _unpack_members(self, buf, offset, length): self.t = res['t'] self.n_obs = res['n_obs'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # t: GPSTimeDep + ret += GPSTimeDep._payload_size() + # n_obs: u8 + ret += 1 + return ret class CarrierPhaseDepA(object): """SBP class for message CarrierPhaseDepA @@ -2731,17 +2918,12 @@ class CarrierPhaseDepA(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__i, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__f, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'i' : __i, - 'f' : __f, - }, offset, length + ret = {} + (__i, offset, length) = get_s32(buf, offset, length) + ret['i'] = __i + (__f, offset, length) = get_u8(buf, offset, length) + ret['f'] = __f + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -2750,6 +2932,15 @@ def _unpack_members(self, buf, offset, length): self.i = res['i'] self.f = res['f'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # i: s32 + ret += 4 + # f: u8 + ret += 1 + return ret class PackedObsContentDepA(object): """SBP class for message PackedObsContentDepA @@ -2770,29 +2961,18 @@ class PackedObsContentDepA(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__P, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__L, offset, length) = offset, CarrierPhaseDepA.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cn0, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__lock, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__prn, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'P' : __P, - 'L' : __L, - 'cn0' : __cn0, - 'lock' : __lock, - 'prn' : __prn, - }, offset, length + ret = {} + (__P, offset, length) = get_u32(buf, offset, length) + ret['P'] = __P + (__L, offset, length) = CarrierPhaseDepA.parse_members(buf, offset, length) + ret['L'] = __L + (__cn0, offset, length) = get_u8(buf, offset, length) + ret['cn0'] = __cn0 + (__lock, offset, length) = get_u16(buf, offset, length) + ret['lock'] = __lock + (__prn, offset, length) = get_u8(buf, offset, length) + ret['prn'] = __prn + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -2804,6 +2984,21 @@ def _unpack_members(self, buf, offset, length): self.lock = res['lock'] self.prn = res['prn'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # P: u32 + ret += 4 + # L: CarrierPhaseDepA + ret += CarrierPhaseDepA._payload_size() + # cn0: u8 + ret += 1 + # lock: u16 + ret += 2 + # prn: u8 + ret += 1 + return ret class PackedObsContentDepB(object): """SBP class for message PackedObsContentDepB @@ -2826,29 +3021,18 @@ class PackedObsContentDepB(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__P, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__L, offset, length) = offset, CarrierPhaseDepA.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cn0, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__lock, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'P' : __P, - 'L' : __L, - 'cn0' : __cn0, - 'lock' : __lock, - 'sid' : __sid, - }, offset, length + ret = {} + (__P, offset, length) = get_u32(buf, offset, length) + ret['P'] = __P + (__L, offset, length) = CarrierPhaseDepA.parse_members(buf, offset, length) + ret['L'] = __L + (__cn0, offset, length) = get_u8(buf, offset, length) + ret['cn0'] = __cn0 + (__lock, offset, length) = get_u16(buf, offset, length) + ret['lock'] = __lock + (__sid, offset, length) = GnssSignalDep.parse_members(buf, offset, length) + ret['sid'] = __sid + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -2860,6 +3044,21 @@ def _unpack_members(self, buf, offset, length): self.lock = res['lock'] self.sid = res['sid'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # P: u32 + ret += 4 + # L: CarrierPhaseDepA + ret += CarrierPhaseDepA._payload_size() + # cn0: u8 + ret += 1 + # lock: u16 + ret += 2 + # sid: GnssSignalDep + ret += GnssSignalDep._payload_size() + return ret class PackedObsContentDepC(object): """SBP class for message PackedObsContentDepC @@ -2883,29 +3082,18 @@ class PackedObsContentDepC(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__P, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__L, offset, length) = offset, CarrierPhase.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cn0, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__lock, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'P' : __P, - 'L' : __L, - 'cn0' : __cn0, - 'lock' : __lock, - 'sid' : __sid, - }, offset, length + ret = {} + (__P, offset, length) = get_u32(buf, offset, length) + ret['P'] = __P + (__L, offset, length) = CarrierPhase.parse_members(buf, offset, length) + ret['L'] = __L + (__cn0, offset, length) = get_u8(buf, offset, length) + ret['cn0'] = __cn0 + (__lock, offset, length) = get_u16(buf, offset, length) + ret['lock'] = __lock + (__sid, offset, length) = GnssSignalDep.parse_members(buf, offset, length) + ret['sid'] = __sid + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -2917,6 +3105,21 @@ def _unpack_members(self, buf, offset, length): self.lock = res['lock'] self.sid = res['sid'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # P: u32 + ret += 4 + # L: CarrierPhase + ret += CarrierPhase._payload_size() + # cn0: u8 + ret += 1 + # lock: u16 + ret += 2 + # sid: GnssSignalDep + ret += GnssSignalDep._payload_size() + return ret SBP_MSG_OBS_DEP_A = 0x0045 class MsgObsDepA(SBP): @@ -2935,17 +3138,12 @@ class MsgObsDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__header, offset, length) = offset, ObservationHeaderDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__obs, offset, length) = offset, get_array(PackedObsContentDepA.parse_members)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'header' : __header, - 'obs' : __obs, - }, offset, length + ret = {} + (__header, offset, length) = ObservationHeaderDep.parse_members(buf, offset, length) + ret['header'] = __header + (__obs, offset, length) = get_array(PackedObsContentDepA.parse_members)(buf, offset, length) + ret['obs'] = __obs + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -2954,6 +3152,15 @@ def _unpack_members(self, buf, offset, length): self.header = res['header'] self.obs = res['obs'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # header: ObservationHeaderDep + ret += ObservationHeaderDep._payload_size() + # obs: array of PackedObsContentDepA + ret += 247 + return ret SBP_MSG_OBS_DEP_B = 0x0043 class MsgObsDepB(SBP): @@ -2978,17 +3185,12 @@ class MsgObsDepB(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__header, offset, length) = offset, ObservationHeaderDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__obs, offset, length) = offset, get_array(PackedObsContentDepB.parse_members)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'header' : __header, - 'obs' : __obs, - }, offset, length + ret = {} + (__header, offset, length) = ObservationHeaderDep.parse_members(buf, offset, length) + ret['header'] = __header + (__obs, offset, length) = get_array(PackedObsContentDepB.parse_members)(buf, offset, length) + ret['obs'] = __obs + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -2997,6 +3199,15 @@ def _unpack_members(self, buf, offset, length): self.header = res['header'] self.obs = res['obs'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # header: ObservationHeaderDep + ret += ObservationHeaderDep._payload_size() + # obs: array of PackedObsContentDepB + ret += 247 + return ret SBP_MSG_OBS_DEP_C = 0x0049 class MsgObsDepC(SBP): @@ -3022,17 +3233,12 @@ class MsgObsDepC(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__header, offset, length) = offset, ObservationHeaderDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__obs, offset, length) = offset, get_array(PackedObsContentDepC.parse_members)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'header' : __header, - 'obs' : __obs, - }, offset, length + ret = {} + (__header, offset, length) = ObservationHeaderDep.parse_members(buf, offset, length) + ret['header'] = __header + (__obs, offset, length) = get_array(PackedObsContentDepC.parse_members)(buf, offset, length) + ret['obs'] = __obs + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -3041,6 +3247,15 @@ def _unpack_members(self, buf, offset, length): self.header = res['header'] self.obs = res['obs'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # header: ObservationHeaderDep + ret += ObservationHeaderDep._payload_size() + # obs: array of PackedObsContentDepC + ret += 247 + return ret SBP_MSG_IONO = 0x0090 class MsgIono(SBP): @@ -3069,45 +3284,26 @@ class MsgIono(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__t_nmct, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__a0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__a1, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__a2, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__a3, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__b0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__b1, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__b2, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__b3, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 't_nmct' : __t_nmct, - 'a0' : __a0, - 'a1' : __a1, - 'a2' : __a2, - 'a3' : __a3, - 'b0' : __b0, - 'b1' : __b1, - 'b2' : __b2, - 'b3' : __b3, - }, offset, length + ret = {} + (__t_nmct, offset, length) = GPSTimeSec.parse_members(buf, offset, length) + ret['t_nmct'] = __t_nmct + (__a0, offset, length) = get_f64(buf, offset, length) + ret['a0'] = __a0 + (__a1, offset, length) = get_f64(buf, offset, length) + ret['a1'] = __a1 + (__a2, offset, length) = get_f64(buf, offset, length) + ret['a2'] = __a2 + (__a3, offset, length) = get_f64(buf, offset, length) + ret['a3'] = __a3 + (__b0, offset, length) = get_f64(buf, offset, length) + ret['b0'] = __b0 + (__b1, offset, length) = get_f64(buf, offset, length) + ret['b1'] = __b1 + (__b2, offset, length) = get_f64(buf, offset, length) + ret['b2'] = __b2 + (__b3, offset, length) = get_f64(buf, offset, length) + ret['b3'] = __b3 + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -3123,6 +3319,29 @@ def _unpack_members(self, buf, offset, length): self.b2 = res['b2'] self.b3 = res['b3'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # t_nmct: GPSTimeSec + ret += GPSTimeSec._payload_size() + # a0: double + ret += 8 + # a1: double + ret += 8 + # a2: double + ret += 8 + # a3: double + ret += 8 + # b0: double + ret += 8 + # b1: double + ret += 8 + # b2: double + ret += 8 + # b3: double + ret += 8 + return ret SBP_MSG_SV_CONFIGURATION_GPS_DEP = 0x0091 class MsgSvConfigurationGPSDep(SBP): @@ -3142,17 +3361,12 @@ class MsgSvConfigurationGPSDep(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__t_nmct, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__l2c_mask, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 't_nmct' : __t_nmct, - 'l2c_mask' : __l2c_mask, - }, offset, length + ret = {} + (__t_nmct, offset, length) = GPSTimeSec.parse_members(buf, offset, length) + ret['t_nmct'] = __t_nmct + (__l2c_mask, offset, length) = get_u32(buf, offset, length) + ret['l2c_mask'] = __l2c_mask + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -3161,6 +3375,15 @@ def _unpack_members(self, buf, offset, length): self.t_nmct = res['t_nmct'] self.l2c_mask = res['l2c_mask'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # t_nmct: GPSTimeSec + ret += GPSTimeSec._payload_size() + # l2c_mask: u32 + ret += 4 + return ret class GnssCapb(object): """SBP class for message GnssCapb @@ -3190,69 +3413,38 @@ class GnssCapb(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__gps_active, offset, length) = offset, get_u64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__gps_l2c, offset, length) = offset, get_u64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__gps_l5, offset, length) = offset, get_u64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__glo_active, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__glo_l2of, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__glo_l3, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sbas_active, offset, length) = offset, get_u64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sbas_l5, offset, length) = offset, get_u64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__bds_active, offset, length) = offset, get_u64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__bds_d2nav, offset, length) = offset, get_u64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__bds_b2, offset, length) = offset, get_u64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__bds_b2a, offset, length) = offset, get_u64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__qzss_active, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__gal_active, offset, length) = offset, get_u64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__gal_e5, offset, length) = offset, get_u64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'gps_active' : __gps_active, - 'gps_l2c' : __gps_l2c, - 'gps_l5' : __gps_l5, - 'glo_active' : __glo_active, - 'glo_l2of' : __glo_l2of, - 'glo_l3' : __glo_l3, - 'sbas_active' : __sbas_active, - 'sbas_l5' : __sbas_l5, - 'bds_active' : __bds_active, - 'bds_d2nav' : __bds_d2nav, - 'bds_b2' : __bds_b2, - 'bds_b2a' : __bds_b2a, - 'qzss_active' : __qzss_active, - 'gal_active' : __gal_active, - 'gal_e5' : __gal_e5, - }, offset, length + ret = {} + (__gps_active, offset, length) = get_u64(buf, offset, length) + ret['gps_active'] = __gps_active + (__gps_l2c, offset, length) = get_u64(buf, offset, length) + ret['gps_l2c'] = __gps_l2c + (__gps_l5, offset, length) = get_u64(buf, offset, length) + ret['gps_l5'] = __gps_l5 + (__glo_active, offset, length) = get_u32(buf, offset, length) + ret['glo_active'] = __glo_active + (__glo_l2of, offset, length) = get_u32(buf, offset, length) + ret['glo_l2of'] = __glo_l2of + (__glo_l3, offset, length) = get_u32(buf, offset, length) + ret['glo_l3'] = __glo_l3 + (__sbas_active, offset, length) = get_u64(buf, offset, length) + ret['sbas_active'] = __sbas_active + (__sbas_l5, offset, length) = get_u64(buf, offset, length) + ret['sbas_l5'] = __sbas_l5 + (__bds_active, offset, length) = get_u64(buf, offset, length) + ret['bds_active'] = __bds_active + (__bds_d2nav, offset, length) = get_u64(buf, offset, length) + ret['bds_d2nav'] = __bds_d2nav + (__bds_b2, offset, length) = get_u64(buf, offset, length) + ret['bds_b2'] = __bds_b2 + (__bds_b2a, offset, length) = get_u64(buf, offset, length) + ret['bds_b2a'] = __bds_b2a + (__qzss_active, offset, length) = get_u32(buf, offset, length) + ret['qzss_active'] = __qzss_active + (__gal_active, offset, length) = get_u64(buf, offset, length) + ret['gal_active'] = __gal_active + (__gal_e5, offset, length) = get_u64(buf, offset, length) + ret['gal_e5'] = __gal_e5 + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -3274,6 +3466,41 @@ def _unpack_members(self, buf, offset, length): self.gal_active = res['gal_active'] self.gal_e5 = res['gal_e5'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # gps_active: u64 + ret += 8 + # gps_l2c: u64 + ret += 8 + # gps_l5: u64 + ret += 8 + # glo_active: u32 + ret += 4 + # glo_l2of: u32 + ret += 4 + # glo_l3: u32 + ret += 4 + # sbas_active: u64 + ret += 8 + # sbas_l5: u64 + ret += 8 + # bds_active: u64 + ret += 8 + # bds_d2nav: u64 + ret += 8 + # bds_b2: u64 + ret += 8 + # bds_b2a: u64 + ret += 8 + # qzss_active: u32 + ret += 4 + # gal_active: u64 + ret += 8 + # gal_e5: u64 + ret += 8 + return ret SBP_MSG_GNSS_CAPB = 0x0096 class MsgGnssCapb(SBP): @@ -3291,17 +3518,12 @@ class MsgGnssCapb(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__t_nmct, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__gc, offset, length) = offset, GnssCapb.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 't_nmct' : __t_nmct, - 'gc' : __gc, - }, offset, length + ret = {} + (__t_nmct, offset, length) = GPSTimeSec.parse_members(buf, offset, length) + ret['t_nmct'] = __t_nmct + (__gc, offset, length) = GnssCapb.parse_members(buf, offset, length) + ret['gc'] = __gc + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -3310,6 +3532,15 @@ def _unpack_members(self, buf, offset, length): self.t_nmct = res['t_nmct'] self.gc = res['gc'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # t_nmct: GPSTimeSec + ret += GPSTimeSec._payload_size() + # gc: GnssCapb + ret += GnssCapb._payload_size() + return ret SBP_MSG_GROUP_DELAY_DEP_A = 0x0092 class MsgGroupDelayDepA(SBP): @@ -3332,33 +3563,20 @@ class MsgGroupDelayDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__t_op, offset, length) = offset, GPSTimeDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__prn, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tgd, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__isc_l1ca, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__isc_l2c, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 't_op' : __t_op, - 'prn' : __prn, - 'valid' : __valid, - 'tgd' : __tgd, - 'isc_l1ca' : __isc_l1ca, - 'isc_l2c' : __isc_l2c, - }, offset, length + ret = {} + (__t_op, offset, length) = GPSTimeDep.parse_members(buf, offset, length) + ret['t_op'] = __t_op + (__prn, offset, length) = get_u8(buf, offset, length) + ret['prn'] = __prn + (__valid, offset, length) = get_u8(buf, offset, length) + ret['valid'] = __valid + (__tgd, offset, length) = get_s16(buf, offset, length) + ret['tgd'] = __tgd + (__isc_l1ca, offset, length) = get_s16(buf, offset, length) + ret['isc_l1ca'] = __isc_l1ca + (__isc_l2c, offset, length) = get_s16(buf, offset, length) + ret['isc_l2c'] = __isc_l2c + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -3371,6 +3589,23 @@ def _unpack_members(self, buf, offset, length): self.isc_l1ca = res['isc_l1ca'] self.isc_l2c = res['isc_l2c'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # t_op: GPSTimeDep + ret += GPSTimeDep._payload_size() + # prn: u8 + ret += 1 + # valid: u8 + ret += 1 + # tgd: s16 + ret += 2 + # isc_l1ca: s16 + ret += 2 + # isc_l2c: s16 + ret += 2 + return ret SBP_MSG_GROUP_DELAY_DEP_B = 0x0093 class MsgGroupDelayDepB(SBP): @@ -3393,33 +3628,20 @@ class MsgGroupDelayDepB(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__t_op, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tgd, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__isc_l1ca, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__isc_l2c, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 't_op' : __t_op, - 'sid' : __sid, - 'valid' : __valid, - 'tgd' : __tgd, - 'isc_l1ca' : __isc_l1ca, - 'isc_l2c' : __isc_l2c, - }, offset, length + ret = {} + (__t_op, offset, length) = GPSTimeSec.parse_members(buf, offset, length) + ret['t_op'] = __t_op + (__sid, offset, length) = GnssSignalDep.parse_members(buf, offset, length) + ret['sid'] = __sid + (__valid, offset, length) = get_u8(buf, offset, length) + ret['valid'] = __valid + (__tgd, offset, length) = get_s16(buf, offset, length) + ret['tgd'] = __tgd + (__isc_l1ca, offset, length) = get_s16(buf, offset, length) + ret['isc_l1ca'] = __isc_l1ca + (__isc_l2c, offset, length) = get_s16(buf, offset, length) + ret['isc_l2c'] = __isc_l2c + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -3432,6 +3654,23 @@ def _unpack_members(self, buf, offset, length): self.isc_l1ca = res['isc_l1ca'] self.isc_l2c = res['isc_l2c'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # t_op: GPSTimeSec + ret += GPSTimeSec._payload_size() + # sid: GnssSignalDep + ret += GnssSignalDep._payload_size() + # valid: u8 + ret += 1 + # tgd: s16 + ret += 2 + # isc_l1ca: s16 + ret += 2 + # isc_l2c: s16 + ret += 2 + return ret SBP_MSG_GROUP_DELAY = 0x0094 class MsgGroupDelay(SBP): @@ -3454,33 +3693,20 @@ class MsgGroupDelay(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__t_op, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tgd, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__isc_l1ca, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__isc_l2c, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 't_op' : __t_op, - 'sid' : __sid, - 'valid' : __valid, - 'tgd' : __tgd, - 'isc_l1ca' : __isc_l1ca, - 'isc_l2c' : __isc_l2c, - }, offset, length + ret = {} + (__t_op, offset, length) = GPSTimeSec.parse_members(buf, offset, length) + ret['t_op'] = __t_op + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + (__valid, offset, length) = get_u8(buf, offset, length) + ret['valid'] = __valid + (__tgd, offset, length) = get_s16(buf, offset, length) + ret['tgd'] = __tgd + (__isc_l1ca, offset, length) = get_s16(buf, offset, length) + ret['isc_l1ca'] = __isc_l1ca + (__isc_l2c, offset, length) = get_s16(buf, offset, length) + ret['isc_l2c'] = __isc_l2c + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -3493,6 +3719,23 @@ def _unpack_members(self, buf, offset, length): self.isc_l1ca = res['isc_l1ca'] self.isc_l2c = res['isc_l2c'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # t_op: GPSTimeSec + ret += GPSTimeSec._payload_size() + # sid: GnssSignal + ret += GnssSignal._payload_size() + # valid: u8 + ret += 1 + # tgd: s16 + ret += 2 + # isc_l1ca: s16 + ret += 2 + # isc_l2c: s16 + ret += 2 + return ret class AlmanacCommonContent(object): """SBP class for message AlmanacCommonContent @@ -3513,33 +3756,20 @@ class AlmanacCommonContent(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toa, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ura, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__fit_interval, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__health_bits, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sid' : __sid, - 'toa' : __toa, - 'ura' : __ura, - 'fit_interval' : __fit_interval, - 'valid' : __valid, - 'health_bits' : __health_bits, - }, offset, length + ret = {} + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + (__toa, offset, length) = GPSTimeSec.parse_members(buf, offset, length) + ret['toa'] = __toa + (__ura, offset, length) = get_f64(buf, offset, length) + ret['ura'] = __ura + (__fit_interval, offset, length) = get_u32(buf, offset, length) + ret['fit_interval'] = __fit_interval + (__valid, offset, length) = get_u8(buf, offset, length) + ret['valid'] = __valid + (__health_bits, offset, length) = get_u8(buf, offset, length) + ret['health_bits'] = __health_bits + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -3552,6 +3782,23 @@ def _unpack_members(self, buf, offset, length): self.valid = res['valid'] self.health_bits = res['health_bits'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sid: GnssSignal + ret += GnssSignal._payload_size() + # toa: GPSTimeSec + ret += GPSTimeSec._payload_size() + # ura: double + ret += 8 + # fit_interval: u32 + ret += 4 + # valid: u8 + ret += 1 + # health_bits: u8 + ret += 1 + return ret class AlmanacCommonContentDep(object): """SBP class for message AlmanacCommonContentDep @@ -3572,33 +3819,20 @@ class AlmanacCommonContentDep(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__toa, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ura, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__fit_interval, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__valid, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__health_bits, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sid' : __sid, - 'toa' : __toa, - 'ura' : __ura, - 'fit_interval' : __fit_interval, - 'valid' : __valid, - 'health_bits' : __health_bits, - }, offset, length + ret = {} + (__sid, offset, length) = GnssSignalDep.parse_members(buf, offset, length) + ret['sid'] = __sid + (__toa, offset, length) = GPSTimeSec.parse_members(buf, offset, length) + ret['toa'] = __toa + (__ura, offset, length) = get_f64(buf, offset, length) + ret['ura'] = __ura + (__fit_interval, offset, length) = get_u32(buf, offset, length) + ret['fit_interval'] = __fit_interval + (__valid, offset, length) = get_u8(buf, offset, length) + ret['valid'] = __valid + (__health_bits, offset, length) = get_u8(buf, offset, length) + ret['health_bits'] = __health_bits + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -3611,6 +3845,23 @@ def _unpack_members(self, buf, offset, length): self.valid = res['valid'] self.health_bits = res['health_bits'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sid: GnssSignalDep + ret += GnssSignalDep._payload_size() + # toa: GPSTimeSec + ret += GPSTimeSec._payload_size() + # ura: double + ret += 8 + # fit_interval: u32 + ret += 4 + # valid: u8 + ret += 1 + # health_bits: u8 + ret += 1 + return ret SBP_MSG_ALMANAC_GPS_DEP = 0x0070 class MsgAlmanacGPSDep(SBP): @@ -3641,49 +3892,28 @@ class MsgAlmanacGPSDep(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__common, offset, length) = offset, AlmanacCommonContentDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'common' : __common, - 'm0' : __m0, - 'ecc' : __ecc, - 'sqrta' : __sqrta, - 'omega0' : __omega0, - 'omegadot' : __omegadot, - 'w' : __w, - 'inc' : __inc, - 'af0' : __af0, - 'af1' : __af1, - }, offset, length + ret = {} + (__common, offset, length) = AlmanacCommonContentDep.parse_members(buf, offset, length) + ret['common'] = __common + (__m0, offset, length) = get_f64(buf, offset, length) + ret['m0'] = __m0 + (__ecc, offset, length) = get_f64(buf, offset, length) + ret['ecc'] = __ecc + (__sqrta, offset, length) = get_f64(buf, offset, length) + ret['sqrta'] = __sqrta + (__omega0, offset, length) = get_f64(buf, offset, length) + ret['omega0'] = __omega0 + (__omegadot, offset, length) = get_f64(buf, offset, length) + ret['omegadot'] = __omegadot + (__w, offset, length) = get_f64(buf, offset, length) + ret['w'] = __w + (__inc, offset, length) = get_f64(buf, offset, length) + ret['inc'] = __inc + (__af0, offset, length) = get_f64(buf, offset, length) + ret['af0'] = __af0 + (__af1, offset, length) = get_f64(buf, offset, length) + ret['af1'] = __af1 + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -3700,6 +3930,31 @@ def _unpack_members(self, buf, offset, length): self.af0 = res['af0'] self.af1 = res['af1'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # common: AlmanacCommonContentDep + ret += AlmanacCommonContentDep._payload_size() + # m0: double + ret += 8 + # ecc: double + ret += 8 + # sqrta: double + ret += 8 + # omega0: double + ret += 8 + # omegadot: double + ret += 8 + # w: double + ret += 8 + # inc: double + ret += 8 + # af0: double + ret += 8 + # af1: double + ret += 8 + return ret SBP_MSG_ALMANAC_GPS = 0x0072 class MsgAlmanacGPS(SBP): @@ -3730,49 +3985,28 @@ class MsgAlmanacGPS(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__common, offset, length) = offset, AlmanacCommonContent.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__m0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ecc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sqrta, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omega0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omegadot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__w, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__inc, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af0, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__af1, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'common' : __common, - 'm0' : __m0, - 'ecc' : __ecc, - 'sqrta' : __sqrta, - 'omega0' : __omega0, - 'omegadot' : __omegadot, - 'w' : __w, - 'inc' : __inc, - 'af0' : __af0, - 'af1' : __af1, - }, offset, length + ret = {} + (__common, offset, length) = AlmanacCommonContent.parse_members(buf, offset, length) + ret['common'] = __common + (__m0, offset, length) = get_f64(buf, offset, length) + ret['m0'] = __m0 + (__ecc, offset, length) = get_f64(buf, offset, length) + ret['ecc'] = __ecc + (__sqrta, offset, length) = get_f64(buf, offset, length) + ret['sqrta'] = __sqrta + (__omega0, offset, length) = get_f64(buf, offset, length) + ret['omega0'] = __omega0 + (__omegadot, offset, length) = get_f64(buf, offset, length) + ret['omegadot'] = __omegadot + (__w, offset, length) = get_f64(buf, offset, length) + ret['w'] = __w + (__inc, offset, length) = get_f64(buf, offset, length) + ret['inc'] = __inc + (__af0, offset, length) = get_f64(buf, offset, length) + ret['af0'] = __af0 + (__af1, offset, length) = get_f64(buf, offset, length) + ret['af1'] = __af1 + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -3789,6 +4023,31 @@ def _unpack_members(self, buf, offset, length): self.af0 = res['af0'] self.af1 = res['af1'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # common: AlmanacCommonContent + ret += AlmanacCommonContent._payload_size() + # m0: double + ret += 8 + # ecc: double + ret += 8 + # sqrta: double + ret += 8 + # omega0: double + ret += 8 + # omegadot: double + ret += 8 + # w: double + ret += 8 + # inc: double + ret += 8 + # af0: double + ret += 8 + # af1: double + ret += 8 + return ret SBP_MSG_ALMANAC_GLO_DEP = 0x0071 class MsgAlmanacGloDep(SBP): @@ -3817,41 +4076,24 @@ class MsgAlmanacGloDep(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__common, offset, length) = offset, AlmanacCommonContentDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__lambda_na, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__t_lambda_na, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__i, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__t, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__t_dot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__epsilon, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omega, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'common' : __common, - 'lambda_na' : __lambda_na, - 't_lambda_na' : __t_lambda_na, - 'i' : __i, - 't' : __t, - 't_dot' : __t_dot, - 'epsilon' : __epsilon, - 'omega' : __omega, - }, offset, length + ret = {} + (__common, offset, length) = AlmanacCommonContentDep.parse_members(buf, offset, length) + ret['common'] = __common + (__lambda_na, offset, length) = get_f64(buf, offset, length) + ret['lambda_na'] = __lambda_na + (__t_lambda_na, offset, length) = get_f64(buf, offset, length) + ret['t_lambda_na'] = __t_lambda_na + (__i, offset, length) = get_f64(buf, offset, length) + ret['i'] = __i + (__t, offset, length) = get_f64(buf, offset, length) + ret['t'] = __t + (__t_dot, offset, length) = get_f64(buf, offset, length) + ret['t_dot'] = __t_dot + (__epsilon, offset, length) = get_f64(buf, offset, length) + ret['epsilon'] = __epsilon + (__omega, offset, length) = get_f64(buf, offset, length) + ret['omega'] = __omega + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -3866,6 +4108,27 @@ def _unpack_members(self, buf, offset, length): self.epsilon = res['epsilon'] self.omega = res['omega'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # common: AlmanacCommonContentDep + ret += AlmanacCommonContentDep._payload_size() + # lambda_na: double + ret += 8 + # t_lambda_na: double + ret += 8 + # i: double + ret += 8 + # t: double + ret += 8 + # t_dot: double + ret += 8 + # epsilon: double + ret += 8 + # omega: double + ret += 8 + return ret SBP_MSG_ALMANAC_GLO = 0x0073 class MsgAlmanacGlo(SBP): @@ -3894,41 +4157,24 @@ class MsgAlmanacGlo(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__common, offset, length) = offset, AlmanacCommonContent.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__lambda_na, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__t_lambda_na, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__i, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__t, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__t_dot, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__epsilon, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__omega, offset, length) = offset, get_f64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'common' : __common, - 'lambda_na' : __lambda_na, - 't_lambda_na' : __t_lambda_na, - 'i' : __i, - 't' : __t, - 't_dot' : __t_dot, - 'epsilon' : __epsilon, - 'omega' : __omega, - }, offset, length + ret = {} + (__common, offset, length) = AlmanacCommonContent.parse_members(buf, offset, length) + ret['common'] = __common + (__lambda_na, offset, length) = get_f64(buf, offset, length) + ret['lambda_na'] = __lambda_na + (__t_lambda_na, offset, length) = get_f64(buf, offset, length) + ret['t_lambda_na'] = __t_lambda_na + (__i, offset, length) = get_f64(buf, offset, length) + ret['i'] = __i + (__t, offset, length) = get_f64(buf, offset, length) + ret['t'] = __t + (__t_dot, offset, length) = get_f64(buf, offset, length) + ret['t_dot'] = __t_dot + (__epsilon, offset, length) = get_f64(buf, offset, length) + ret['epsilon'] = __epsilon + (__omega, offset, length) = get_f64(buf, offset, length) + ret['omega'] = __omega + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -3943,6 +4189,27 @@ def _unpack_members(self, buf, offset, length): self.epsilon = res['epsilon'] self.omega = res['omega'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # common: AlmanacCommonContent + ret += AlmanacCommonContent._payload_size() + # lambda_na: double + ret += 8 + # t_lambda_na: double + ret += 8 + # i: double + ret += 8 + # t: double + ret += 8 + # t_dot: double + ret += 8 + # epsilon: double + ret += 8 + # omega: double + ret += 8 + return ret SBP_MSG_GLO_BIASES = 0x0075 class MsgGloBiases(SBP): @@ -3968,29 +4235,18 @@ class MsgGloBiases(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__mask, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__l1ca_bias, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__l1p_bias, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__l2ca_bias, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__l2p_bias, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'mask' : __mask, - 'l1ca_bias' : __l1ca_bias, - 'l1p_bias' : __l1p_bias, - 'l2ca_bias' : __l2ca_bias, - 'l2p_bias' : __l2p_bias, - }, offset, length + ret = {} + (__mask, offset, length) = get_u8(buf, offset, length) + ret['mask'] = __mask + (__l1ca_bias, offset, length) = get_s16(buf, offset, length) + ret['l1ca_bias'] = __l1ca_bias + (__l1p_bias, offset, length) = get_s16(buf, offset, length) + ret['l1p_bias'] = __l1p_bias + (__l2ca_bias, offset, length) = get_s16(buf, offset, length) + ret['l2ca_bias'] = __l2ca_bias + (__l2p_bias, offset, length) = get_s16(buf, offset, length) + ret['l2p_bias'] = __l2p_bias + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -4002,6 +4258,146 @@ def _unpack_members(self, buf, offset, length): self.l2ca_bias = res['l2ca_bias'] self.l2p_bias = res['l2p_bias'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # mask: u8 + ret += 1 + # l1ca_bias: s16 + ret += 2 + # l1p_bias: s16 + ret += 2 + # l2ca_bias: s16 + ret += 2 + # l2p_bias: s16 + ret += 2 + return ret + +class SvAzEl(object): + """SBP class for message SvAzEl + + You can have SvAzEl inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Satellite azimuth and elevation. + + """ + __slots__ = ['sid', + 'az', + 'el', + ] + @classmethod + def parse_members(cls, buf, offset, length): + ret = {} + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + (__az, offset, length) = get_u8(buf, offset, length) + ret['az'] = __az + (__el, offset, length) = get_s8(buf, offset, length) + ret['el'] = __el + return ret, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.sid = res['sid'] + self.az = res['az'] + self.el = res['el'] + return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sid: GnssSignal + ret += GnssSignal._payload_size() + # az: u8 + ret += 1 + # el: s8 + ret += 1 + return ret + +SBP_MSG_SV_AZ_EL = 0x0097 +class MsgSvAzEl(SBP): + """SBP class for message MSG_SV_AZ_EL (0x0097). + + You can have MSG_SV_AZ_EL inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Azimuth and elevation angles of all the visible satellites +that the device does have ephemeris or almanac for. + + + """ + __slots__ = ['azel', + ] + @classmethod + def parse_members(cls, buf, offset, length): + ret = {} + (__azel, offset, length) = get_array(SvAzEl.parse_members)(buf, offset, length) + ret['azel'] = __azel + return ret, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.azel = res['azel'] + return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # azel: array of SvAzEl + ret += 247 + return ret + +SBP_MSG_OSR = 0x0640 +class MsgOsr(SBP): + """SBP class for message MSG_OSR (0x0640). + + You can have MSG_OSR inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + The OSR message contains network corrections in an observation-like format + + + """ + __slots__ = ['header', + 'obs', + ] + @classmethod + def parse_members(cls, buf, offset, length): + ret = {} + (__header, offset, length) = ObservationHeader.parse_members(buf, offset, length) + ret['header'] = __header + (__obs, offset, length) = get_array(PackedOsrContent.parse_members)(buf, offset, length) + ret['obs'] = __obs + return ret, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.header = res['header'] + self.obs = res['obs'] + return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # header: ObservationHeader + ret += ObservationHeader._payload_size() + # obs: array of PackedOsrContent + ret += 247 + return ret msg_classes = { @@ -4039,4 +4435,6 @@ def _unpack_members(self, buf, offset, length): 0x0071: MsgAlmanacGloDep, 0x0073: MsgAlmanacGlo, 0x0075: MsgGloBiases, + 0x0097: MsgSvAzEl, + 0x0640: MsgOsr, } \ No newline at end of file diff --git a/python/sbp/jit/orientation.py b/python/sbp/jit/orientation.py index 3740074e3f..5ed7f4cbc8 100644 --- a/python/sbp/jit/orientation.py +++ b/python/sbp/jit/orientation.py @@ -16,11 +16,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array # Automatically generated from piksi/yaml/swiftnav/sbp/orientation.yaml with generate.py. @@ -48,25 +50,16 @@ class MsgBaselineHeading(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__heading, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__n_sats, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'heading' : __heading, - 'n_sats' : __n_sats, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__heading, offset, length) = get_u32(buf, offset, length) + ret['heading'] = __heading + (__n_sats, offset, length) = get_u8(buf, offset, length) + ret['n_sats'] = __n_sats + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -77,6 +70,19 @@ def _unpack_members(self, buf, offset, length): self.n_sats = res['n_sats'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # heading: u32 + ret += 4 + # n_sats: u8 + ret += 1 + # flags: u8 + ret += 1 + return ret SBP_MSG_ORIENT_QUAT = 0x0220 class MsgOrientQuat(SBP): @@ -108,49 +114,28 @@ class MsgOrientQuat(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__w, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__x, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__y, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__z, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__w_accuracy, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__x_accuracy, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__y_accuracy, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__z_accuracy, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'w' : __w, - 'x' : __x, - 'y' : __y, - 'z' : __z, - 'w_accuracy' : __w_accuracy, - 'x_accuracy' : __x_accuracy, - 'y_accuracy' : __y_accuracy, - 'z_accuracy' : __z_accuracy, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__w, offset, length) = get_s32(buf, offset, length) + ret['w'] = __w + (__x, offset, length) = get_s32(buf, offset, length) + ret['x'] = __x + (__y, offset, length) = get_s32(buf, offset, length) + ret['y'] = __y + (__z, offset, length) = get_s32(buf, offset, length) + ret['z'] = __z + (__w_accuracy, offset, length) = get_f32(buf, offset, length) + ret['w_accuracy'] = judicious_round(nb.f4(__w_accuracy)) if SBP.judicious_rounding else __w_accuracy + (__x_accuracy, offset, length) = get_f32(buf, offset, length) + ret['x_accuracy'] = judicious_round(nb.f4(__x_accuracy)) if SBP.judicious_rounding else __x_accuracy + (__y_accuracy, offset, length) = get_f32(buf, offset, length) + ret['y_accuracy'] = judicious_round(nb.f4(__y_accuracy)) if SBP.judicious_rounding else __y_accuracy + (__z_accuracy, offset, length) = get_f32(buf, offset, length) + ret['z_accuracy'] = judicious_round(nb.f4(__z_accuracy)) if SBP.judicious_rounding else __z_accuracy + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -167,6 +152,31 @@ def _unpack_members(self, buf, offset, length): self.z_accuracy = res['z_accuracy'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # w: s32 + ret += 4 + # x: s32 + ret += 4 + # y: s32 + ret += 4 + # z: s32 + ret += 4 + # w_accuracy: float + ret += 4 + # x_accuracy: float + ret += 4 + # y_accuracy: float + ret += 4 + # z_accuracy: float + ret += 4 + # flags: u8 + ret += 1 + return ret SBP_MSG_ORIENT_EULER = 0x0221 class MsgOrientEuler(SBP): @@ -196,41 +206,24 @@ class MsgOrientEuler(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__roll, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pitch, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__yaw, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__roll_accuracy, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pitch_accuracy, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__yaw_accuracy, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'roll' : __roll, - 'pitch' : __pitch, - 'yaw' : __yaw, - 'roll_accuracy' : __roll_accuracy, - 'pitch_accuracy' : __pitch_accuracy, - 'yaw_accuracy' : __yaw_accuracy, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__roll, offset, length) = get_s32(buf, offset, length) + ret['roll'] = __roll + (__pitch, offset, length) = get_s32(buf, offset, length) + ret['pitch'] = __pitch + (__yaw, offset, length) = get_s32(buf, offset, length) + ret['yaw'] = __yaw + (__roll_accuracy, offset, length) = get_f32(buf, offset, length) + ret['roll_accuracy'] = judicious_round(nb.f4(__roll_accuracy)) if SBP.judicious_rounding else __roll_accuracy + (__pitch_accuracy, offset, length) = get_f32(buf, offset, length) + ret['pitch_accuracy'] = judicious_round(nb.f4(__pitch_accuracy)) if SBP.judicious_rounding else __pitch_accuracy + (__yaw_accuracy, offset, length) = get_f32(buf, offset, length) + ret['yaw_accuracy'] = judicious_round(nb.f4(__yaw_accuracy)) if SBP.judicious_rounding else __yaw_accuracy + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -245,6 +238,27 @@ def _unpack_members(self, buf, offset, length): self.yaw_accuracy = res['yaw_accuracy'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # roll: s32 + ret += 4 + # pitch: s32 + ret += 4 + # yaw: s32 + ret += 4 + # roll_accuracy: float + ret += 4 + # pitch_accuracy: float + ret += 4 + # yaw_accuracy: float + ret += 4 + # flags: u8 + ret += 1 + return ret SBP_MSG_ANGULAR_RATE = 0x0222 class MsgAngularRate(SBP): @@ -275,29 +289,18 @@ class MsgAngularRate(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__x, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__y, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__z, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'x' : __x, - 'y' : __y, - 'z' : __z, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__x, offset, length) = get_s32(buf, offset, length) + ret['x'] = __x + (__y, offset, length) = get_s32(buf, offset, length) + ret['y'] = __y + (__z, offset, length) = get_s32(buf, offset, length) + ret['z'] = __z + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -309,6 +312,21 @@ def _unpack_members(self, buf, offset, length): self.z = res['z'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # x: s32 + ret += 4 + # y: s32 + ret += 4 + # z: s32 + ret += 4 + # flags: u8 + ret += 1 + return ret msg_classes = { diff --git a/python/sbp/jit/piksi.py b/python/sbp/jit/piksi.py index aacb052f2d..8175df26aa 100644 --- a/python/sbp/jit/piksi.py +++ b/python/sbp/jit/piksi.py @@ -19,11 +19,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array from sbp.jit.gnss import * @@ -44,6 +46,11 @@ class MsgAlmanac(SBP): """ __slots__ = [] + def _unpack_members(self, buf, offset, length): + return {}, offset, length + + def _payload_size(self): + return 0 SBP_MSG_SET_TIME = 0x0068 class MsgSetTime(SBP): @@ -60,6 +67,11 @@ class MsgSetTime(SBP): """ __slots__ = [] + def _unpack_members(self, buf, offset, length): + return {}, offset, length + + def _payload_size(self): + return 0 SBP_MSG_RESET = 0x00B6 class MsgReset(SBP): @@ -79,13 +91,10 @@ class MsgReset(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__flags, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'flags' : __flags, - }, offset, length + ret = {} + (__flags, offset, length) = get_u32(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -93,6 +102,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # flags: u32 + ret += 4 + return ret SBP_MSG_RESET_DEP = 0x00B2 class MsgResetDep(SBP): @@ -109,6 +125,11 @@ class MsgResetDep(SBP): """ __slots__ = [] + def _unpack_members(self, buf, offset, length): + return {}, offset, length + + def _payload_size(self): + return 0 SBP_MSG_CW_RESULTS = 0x00C0 class MsgCwResults(SBP): @@ -126,6 +147,11 @@ class MsgCwResults(SBP): """ __slots__ = [] + def _unpack_members(self, buf, offset, length): + return {}, offset, length + + def _payload_size(self): + return 0 SBP_MSG_CW_START = 0x00C1 class MsgCwStart(SBP): @@ -143,6 +169,11 @@ class MsgCwStart(SBP): """ __slots__ = [] + def _unpack_members(self, buf, offset, length): + return {}, offset, length + + def _payload_size(self): + return 0 SBP_MSG_RESET_FILTERS = 0x0022 class MsgResetFilters(SBP): @@ -162,13 +193,10 @@ class MsgResetFilters(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__filter, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'filter' : __filter, - }, offset, length + ret = {} + (__filter, offset, length) = get_u8(buf, offset, length) + ret['filter'] = __filter + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -176,6 +204,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.filter = res['filter'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # filter: u8 + ret += 1 + return ret SBP_MSG_INIT_BASE = 0x0023 class MsgInitBase(SBP): @@ -195,6 +230,11 @@ class MsgInitBase(SBP): """ __slots__ = [] + def _unpack_members(self, buf, offset, length): + return {}, offset, length + + def _payload_size(self): + return 0 SBP_MSG_THREAD_STATE = 0x0017 class MsgThreadState(SBP): @@ -217,21 +257,14 @@ class MsgThreadState(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__name, offset, length) = offset, get_fixed_string(20)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cpu, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__stack_free, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'name' : __name, - 'cpu' : __cpu, - 'stack_free' : __stack_free, - }, offset, length + ret = {} + (__name, offset, length) = get_fixed_string(20)(buf, offset, length) + ret['name'] = __name + (__cpu, offset, length) = get_u16(buf, offset, length) + ret['cpu'] = __cpu + (__stack_free, offset, length) = get_u32(buf, offset, length) + ret['stack_free'] = __stack_free + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -241,6 +274,17 @@ def _unpack_members(self, buf, offset, length): self.cpu = res['cpu'] self.stack_free = res['stack_free'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # name: string + ret += 20 + # cpu: u16 + ret += 2 + # stack_free: u32 + ret += 4 + return ret class UARTChannel(object): """SBP class for message UARTChannel @@ -265,33 +309,20 @@ class UARTChannel(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tx_throughput, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__rx_throughput, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__crc_error_count, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__io_error_count, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tx_buffer_level, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__rx_buffer_level, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tx_throughput' : __tx_throughput, - 'rx_throughput' : __rx_throughput, - 'crc_error_count' : __crc_error_count, - 'io_error_count' : __io_error_count, - 'tx_buffer_level' : __tx_buffer_level, - 'rx_buffer_level' : __rx_buffer_level, - }, offset, length + ret = {} + (__tx_throughput, offset, length) = get_f32(buf, offset, length) + ret['tx_throughput'] = judicious_round(nb.f4(__tx_throughput)) if SBP.judicious_rounding else __tx_throughput + (__rx_throughput, offset, length) = get_f32(buf, offset, length) + ret['rx_throughput'] = judicious_round(nb.f4(__rx_throughput)) if SBP.judicious_rounding else __rx_throughput + (__crc_error_count, offset, length) = get_u16(buf, offset, length) + ret['crc_error_count'] = __crc_error_count + (__io_error_count, offset, length) = get_u16(buf, offset, length) + ret['io_error_count'] = __io_error_count + (__tx_buffer_level, offset, length) = get_u8(buf, offset, length) + ret['tx_buffer_level'] = __tx_buffer_level + (__rx_buffer_level, offset, length) = get_u8(buf, offset, length) + ret['rx_buffer_level'] = __rx_buffer_level + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -304,6 +335,23 @@ def _unpack_members(self, buf, offset, length): self.tx_buffer_level = res['tx_buffer_level'] self.rx_buffer_level = res['rx_buffer_level'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tx_throughput: float + ret += 4 + # rx_throughput: float + ret += 4 + # crc_error_count: u16 + ret += 2 + # io_error_count: u16 + ret += 2 + # tx_buffer_level: u8 + ret += 1 + # rx_buffer_level: u8 + ret += 1 + return ret class Period(object): """SBP class for message Period @@ -329,25 +377,16 @@ class Period(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__avg, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pmin, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pmax, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__current, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'avg' : __avg, - 'pmin' : __pmin, - 'pmax' : __pmax, - 'current' : __current, - }, offset, length + ret = {} + (__avg, offset, length) = get_s32(buf, offset, length) + ret['avg'] = __avg + (__pmin, offset, length) = get_s32(buf, offset, length) + ret['pmin'] = __pmin + (__pmax, offset, length) = get_s32(buf, offset, length) + ret['pmax'] = __pmax + (__current, offset, length) = get_s32(buf, offset, length) + ret['current'] = __current + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -358,6 +397,19 @@ def _unpack_members(self, buf, offset, length): self.pmax = res['pmax'] self.current = res['current'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # avg: s32 + ret += 4 + # pmin: s32 + ret += 4 + # pmax: s32 + ret += 4 + # current: s32 + ret += 4 + return ret class Latency(object): """SBP class for message Latency @@ -382,25 +434,16 @@ class Latency(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__avg, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__lmin, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__lmax, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__current, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'avg' : __avg, - 'lmin' : __lmin, - 'lmax' : __lmax, - 'current' : __current, - }, offset, length + ret = {} + (__avg, offset, length) = get_s32(buf, offset, length) + ret['avg'] = __avg + (__lmin, offset, length) = get_s32(buf, offset, length) + ret['lmin'] = __lmin + (__lmax, offset, length) = get_s32(buf, offset, length) + ret['lmax'] = __lmax + (__current, offset, length) = get_s32(buf, offset, length) + ret['current'] = __current + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -411,6 +454,19 @@ def _unpack_members(self, buf, offset, length): self.lmax = res['lmax'] self.current = res['current'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # avg: s32 + ret += 4 + # lmin: s32 + ret += 4 + # lmax: s32 + ret += 4 + # current: s32 + ret += 4 + return ret SBP_MSG_UART_STATE = 0x001D class MsgUartState(SBP): @@ -441,29 +497,18 @@ class MsgUartState(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__uart_a, offset, length) = offset, UARTChannel.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__uart_b, offset, length) = offset, UARTChannel.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__uart_ftdi, offset, length) = offset, UARTChannel.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__latency, offset, length) = offset, Latency.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__obs_period, offset, length) = offset, Period.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'uart_a' : __uart_a, - 'uart_b' : __uart_b, - 'uart_ftdi' : __uart_ftdi, - 'latency' : __latency, - 'obs_period' : __obs_period, - }, offset, length + ret = {} + (__uart_a, offset, length) = UARTChannel.parse_members(buf, offset, length) + ret['uart_a'] = __uart_a + (__uart_b, offset, length) = UARTChannel.parse_members(buf, offset, length) + ret['uart_b'] = __uart_b + (__uart_ftdi, offset, length) = UARTChannel.parse_members(buf, offset, length) + ret['uart_ftdi'] = __uart_ftdi + (__latency, offset, length) = Latency.parse_members(buf, offset, length) + ret['latency'] = __latency + (__obs_period, offset, length) = Period.parse_members(buf, offset, length) + ret['obs_period'] = __obs_period + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -475,6 +520,21 @@ def _unpack_members(self, buf, offset, length): self.latency = res['latency'] self.obs_period = res['obs_period'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # uart_a: UARTChannel + ret += UARTChannel._payload_size() + # uart_b: UARTChannel + ret += UARTChannel._payload_size() + # uart_ftdi: UARTChannel + ret += UARTChannel._payload_size() + # latency: Latency + ret += Latency._payload_size() + # obs_period: Period + ret += Period._payload_size() + return ret SBP_MSG_UART_STATE_DEPA = 0x0018 class MsgUartStateDepa(SBP): @@ -495,25 +555,16 @@ class MsgUartStateDepa(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__uart_a, offset, length) = offset, UARTChannel.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__uart_b, offset, length) = offset, UARTChannel.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__uart_ftdi, offset, length) = offset, UARTChannel.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__latency, offset, length) = offset, Latency.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'uart_a' : __uart_a, - 'uart_b' : __uart_b, - 'uart_ftdi' : __uart_ftdi, - 'latency' : __latency, - }, offset, length + ret = {} + (__uart_a, offset, length) = UARTChannel.parse_members(buf, offset, length) + ret['uart_a'] = __uart_a + (__uart_b, offset, length) = UARTChannel.parse_members(buf, offset, length) + ret['uart_b'] = __uart_b + (__uart_ftdi, offset, length) = UARTChannel.parse_members(buf, offset, length) + ret['uart_ftdi'] = __uart_ftdi + (__latency, offset, length) = Latency.parse_members(buf, offset, length) + ret['latency'] = __latency + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -524,6 +575,19 @@ def _unpack_members(self, buf, offset, length): self.uart_ftdi = res['uart_ftdi'] self.latency = res['latency'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # uart_a: UARTChannel + ret += UARTChannel._payload_size() + # uart_b: UARTChannel + ret += UARTChannel._payload_size() + # uart_ftdi: UARTChannel + ret += UARTChannel._payload_size() + # latency: Latency + ret += Latency._payload_size() + return ret SBP_MSG_IAR_STATE = 0x0019 class MsgIarState(SBP): @@ -545,13 +609,10 @@ class MsgIarState(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__num_hyps, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'num_hyps' : __num_hyps, - }, offset, length + ret = {} + (__num_hyps, offset, length) = get_u32(buf, offset, length) + ret['num_hyps'] = __num_hyps + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -559,6 +620,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.num_hyps = res['num_hyps'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # num_hyps: u32 + ret += 4 + return ret SBP_MSG_MASK_SATELLITE = 0x002B class MsgMaskSatellite(SBP): @@ -579,17 +647,12 @@ class MsgMaskSatellite(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__mask, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'mask' : __mask, - 'sid' : __sid, - }, offset, length + ret = {} + (__mask, offset, length) = get_u8(buf, offset, length) + ret['mask'] = __mask + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -598,6 +661,15 @@ def _unpack_members(self, buf, offset, length): self.mask = res['mask'] self.sid = res['sid'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # mask: u8 + ret += 1 + # sid: GnssSignal + ret += GnssSignal._payload_size() + return ret SBP_MSG_MASK_SATELLITE_DEP = 0x001B class MsgMaskSatelliteDep(SBP): @@ -616,17 +688,12 @@ class MsgMaskSatelliteDep(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__mask, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'mask' : __mask, - 'sid' : __sid, - }, offset, length + ret = {} + (__mask, offset, length) = get_u8(buf, offset, length) + ret['mask'] = __mask + (__sid, offset, length) = GnssSignalDep.parse_members(buf, offset, length) + ret['sid'] = __sid + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -635,6 +702,15 @@ def _unpack_members(self, buf, offset, length): self.mask = res['mask'] self.sid = res['sid'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # mask: u8 + ret += 1 + # sid: GnssSignalDep + ret += GnssSignalDep._payload_size() + return ret SBP_MSG_DEVICE_MONITOR = 0x00B5 class MsgDeviceMonitor(SBP): @@ -659,29 +735,18 @@ class MsgDeviceMonitor(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__dev_vin, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cpu_vint, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cpu_vaux, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cpu_temperature, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__fe_temperature, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'dev_vin' : __dev_vin, - 'cpu_vint' : __cpu_vint, - 'cpu_vaux' : __cpu_vaux, - 'cpu_temperature' : __cpu_temperature, - 'fe_temperature' : __fe_temperature, - }, offset, length + ret = {} + (__dev_vin, offset, length) = get_s16(buf, offset, length) + ret['dev_vin'] = __dev_vin + (__cpu_vint, offset, length) = get_s16(buf, offset, length) + ret['cpu_vint'] = __cpu_vint + (__cpu_vaux, offset, length) = get_s16(buf, offset, length) + ret['cpu_vaux'] = __cpu_vaux + (__cpu_temperature, offset, length) = get_s16(buf, offset, length) + ret['cpu_temperature'] = __cpu_temperature + (__fe_temperature, offset, length) = get_s16(buf, offset, length) + ret['fe_temperature'] = __fe_temperature + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -693,6 +758,21 @@ def _unpack_members(self, buf, offset, length): self.cpu_temperature = res['cpu_temperature'] self.fe_temperature = res['fe_temperature'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # dev_vin: s16 + ret += 2 + # cpu_vint: s16 + ret += 2 + # cpu_vaux: s16 + ret += 2 + # cpu_temperature: s16 + ret += 2 + # fe_temperature: s16 + ret += 2 + return ret SBP_MSG_COMMAND_REQ = 0x00B8 class MsgCommandReq(SBP): @@ -714,17 +794,12 @@ class MsgCommandReq(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__command, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sequence' : __sequence, - 'command' : __command, - }, offset, length + ret = {} + (__sequence, offset, length) = get_u32(buf, offset, length) + ret['sequence'] = __sequence + (__command, offset, length) = get_string(buf, offset, length) + ret['command'] = __command + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -733,6 +808,15 @@ def _unpack_members(self, buf, offset, length): self.sequence = res['sequence'] self.command = res['command'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sequence: u32 + ret += 4 + # command: string + ret += 247 + return ret SBP_MSG_COMMAND_RESP = 0x00B9 class MsgCommandResp(SBP): @@ -753,17 +837,12 @@ class MsgCommandResp(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__code, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sequence' : __sequence, - 'code' : __code, - }, offset, length + ret = {} + (__sequence, offset, length) = get_u32(buf, offset, length) + ret['sequence'] = __sequence + (__code, offset, length) = get_s32(buf, offset, length) + ret['code'] = __code + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -772,6 +851,15 @@ def _unpack_members(self, buf, offset, length): self.sequence = res['sequence'] self.code = res['code'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sequence: u32 + ret += 4 + # code: s32 + ret += 4 + return ret SBP_MSG_COMMAND_OUTPUT = 0x00BC class MsgCommandOutput(SBP): @@ -794,17 +882,12 @@ class MsgCommandOutput(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sequence, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__line, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sequence' : __sequence, - 'line' : __line, - }, offset, length + ret = {} + (__sequence, offset, length) = get_u32(buf, offset, length) + ret['sequence'] = __sequence + (__line, offset, length) = get_string(buf, offset, length) + ret['line'] = __line + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -813,6 +896,15 @@ def _unpack_members(self, buf, offset, length): self.sequence = res['sequence'] self.line = res['line'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sequence: u32 + ret += 4 + # line: string + ret += 247 + return ret SBP_MSG_NETWORK_STATE_REQ = 0x00BA class MsgNetworkStateReq(SBP): @@ -829,6 +921,11 @@ class MsgNetworkStateReq(SBP): """ __slots__ = [] + def _unpack_members(self, buf, offset, length): + return {}, offset, length + + def _payload_size(self): + return 0 SBP_MSG_NETWORK_STATE_RESP = 0x00BB class MsgNetworkStateResp(SBP): @@ -856,41 +953,24 @@ class MsgNetworkStateResp(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__ipv4_address, offset, length) = offset, get_fixed_array(get_u8, 4, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ipv4_mask_size, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ipv6_address, offset, length) = offset, get_fixed_array(get_u8, 16, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__ipv6_mask_size, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__rx_bytes, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tx_bytes, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__interface_name, offset, length) = offset, get_fixed_string(16)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'ipv4_address' : __ipv4_address, - 'ipv4_mask_size' : __ipv4_mask_size, - 'ipv6_address' : __ipv6_address, - 'ipv6_mask_size' : __ipv6_mask_size, - 'rx_bytes' : __rx_bytes, - 'tx_bytes' : __tx_bytes, - 'interface_name' : __interface_name, - 'flags' : __flags, - }, offset, length + ret = {} + (__ipv4_address, offset, length) = get_fixed_array(get_u8, 4, 1)(buf, offset, length) + ret['ipv4_address'] = __ipv4_address + (__ipv4_mask_size, offset, length) = get_u8(buf, offset, length) + ret['ipv4_mask_size'] = __ipv4_mask_size + (__ipv6_address, offset, length) = get_fixed_array(get_u8, 16, 1)(buf, offset, length) + ret['ipv6_address'] = __ipv6_address + (__ipv6_mask_size, offset, length) = get_u8(buf, offset, length) + ret['ipv6_mask_size'] = __ipv6_mask_size + (__rx_bytes, offset, length) = get_u32(buf, offset, length) + ret['rx_bytes'] = __rx_bytes + (__tx_bytes, offset, length) = get_u32(buf, offset, length) + ret['tx_bytes'] = __tx_bytes + (__interface_name, offset, length) = get_fixed_string(16)(buf, offset, length) + ret['interface_name'] = __interface_name + (__flags, offset, length) = get_u32(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -905,6 +985,27 @@ def _unpack_members(self, buf, offset, length): self.interface_name = res['interface_name'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # ipv4_address: array of u8 + ret += 1 * 4 + # ipv4_mask_size: u8 + ret += 1 + # ipv6_address: array of u8 + ret += 1 * 16 + # ipv6_mask_size: u8 + ret += 1 + # rx_bytes: u32 + ret += 4 + # tx_bytes: u32 + ret += 4 + # interface_name: string + ret += 16 + # flags: u32 + ret += 4 + return ret class NetworkUsage(object): """SBP class for message NetworkUsage @@ -931,29 +1032,18 @@ class NetworkUsage(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__duration, offset, length) = offset, get_u64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__total_bytes, offset, length) = offset, get_u64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__rx_bytes, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tx_bytes, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__interface_name, offset, length) = offset, get_fixed_string(16)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'duration' : __duration, - 'total_bytes' : __total_bytes, - 'rx_bytes' : __rx_bytes, - 'tx_bytes' : __tx_bytes, - 'interface_name' : __interface_name, - }, offset, length + ret = {} + (__duration, offset, length) = get_u64(buf, offset, length) + ret['duration'] = __duration + (__total_bytes, offset, length) = get_u64(buf, offset, length) + ret['total_bytes'] = __total_bytes + (__rx_bytes, offset, length) = get_u32(buf, offset, length) + ret['rx_bytes'] = __rx_bytes + (__tx_bytes, offset, length) = get_u32(buf, offset, length) + ret['tx_bytes'] = __tx_bytes + (__interface_name, offset, length) = get_fixed_string(16)(buf, offset, length) + ret['interface_name'] = __interface_name + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -965,6 +1055,21 @@ def _unpack_members(self, buf, offset, length): self.tx_bytes = res['tx_bytes'] self.interface_name = res['interface_name'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # duration: u64 + ret += 8 + # total_bytes: u64 + ret += 8 + # rx_bytes: u32 + ret += 4 + # tx_bytes: u32 + ret += 4 + # interface_name: string + ret += 16 + return ret SBP_MSG_NETWORK_BANDWIDTH_USAGE = 0x00BD class MsgNetworkBandwidthUsage(SBP): @@ -983,13 +1088,10 @@ class MsgNetworkBandwidthUsage(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__interfaces, offset, length) = offset, get_array(NetworkUsage.parse_members)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'interfaces' : __interfaces, - }, offset, length + ret = {} + (__interfaces, offset, length) = get_array(NetworkUsage.parse_members)(buf, offset, length) + ret['interfaces'] = __interfaces + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -997,6 +1099,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.interfaces = res['interfaces'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # interfaces: array of NetworkUsage + ret += 247 + return ret SBP_MSG_CELL_MODEM_STATUS = 0x00BE class MsgCellModemStatus(SBP): @@ -1019,21 +1128,14 @@ class MsgCellModemStatus(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__signal_strength, offset, length) = offset, get_s8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__signal_error_rate, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__reserved, offset, length) = offset, get_array(get_u8)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'signal_strength' : __signal_strength, - 'signal_error_rate' : __signal_error_rate, - 'reserved' : __reserved, - }, offset, length + ret = {} + (__signal_strength, offset, length) = get_s8(buf, offset, length) + ret['signal_strength'] = __signal_strength + (__signal_error_rate, offset, length) = get_f32(buf, offset, length) + ret['signal_error_rate'] = judicious_round(nb.f4(__signal_error_rate)) if SBP.judicious_rounding else __signal_error_rate + (__reserved, offset, length) = get_array(get_u8)(buf, offset, length) + ret['reserved'] = __reserved + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1043,6 +1145,17 @@ def _unpack_members(self, buf, offset, length): self.signal_error_rate = res['signal_error_rate'] self.reserved = res['reserved'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # signal_strength: s8 + ret += 1 + # signal_error_rate: float + ret += 4 + # reserved: array of u8 + ret += 247 + return ret SBP_MSG_SPECAN_DEP = 0x0050 class MsgSpecanDep(SBP): @@ -1066,37 +1179,22 @@ class MsgSpecanDep(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__channel_tag, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__t, offset, length) = offset, GPSTimeDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__freq_ref, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__freq_step, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__amplitude_ref, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__amplitude_unit, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__amplitude_value, offset, length) = offset, get_array(get_u8)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'channel_tag' : __channel_tag, - 't' : __t, - 'freq_ref' : __freq_ref, - 'freq_step' : __freq_step, - 'amplitude_ref' : __amplitude_ref, - 'amplitude_unit' : __amplitude_unit, - 'amplitude_value' : __amplitude_value, - }, offset, length + ret = {} + (__channel_tag, offset, length) = get_u16(buf, offset, length) + ret['channel_tag'] = __channel_tag + (__t, offset, length) = GPSTimeDep.parse_members(buf, offset, length) + ret['t'] = __t + (__freq_ref, offset, length) = get_f32(buf, offset, length) + ret['freq_ref'] = judicious_round(nb.f4(__freq_ref)) if SBP.judicious_rounding else __freq_ref + (__freq_step, offset, length) = get_f32(buf, offset, length) + ret['freq_step'] = judicious_round(nb.f4(__freq_step)) if SBP.judicious_rounding else __freq_step + (__amplitude_ref, offset, length) = get_f32(buf, offset, length) + ret['amplitude_ref'] = judicious_round(nb.f4(__amplitude_ref)) if SBP.judicious_rounding else __amplitude_ref + (__amplitude_unit, offset, length) = get_f32(buf, offset, length) + ret['amplitude_unit'] = judicious_round(nb.f4(__amplitude_unit)) if SBP.judicious_rounding else __amplitude_unit + (__amplitude_value, offset, length) = get_array(get_u8)(buf, offset, length) + ret['amplitude_value'] = __amplitude_value + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1110,6 +1208,25 @@ def _unpack_members(self, buf, offset, length): self.amplitude_unit = res['amplitude_unit'] self.amplitude_value = res['amplitude_value'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # channel_tag: u16 + ret += 2 + # t: GPSTimeDep + ret += GPSTimeDep._payload_size() + # freq_ref: float + ret += 4 + # freq_step: float + ret += 4 + # amplitude_ref: float + ret += 4 + # amplitude_unit: float + ret += 4 + # amplitude_value: array of u8 + ret += 247 + return ret SBP_MSG_SPECAN = 0x0051 class MsgSpecan(SBP): @@ -1134,37 +1251,22 @@ class MsgSpecan(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__channel_tag, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__t, offset, length) = offset, GPSTime.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__freq_ref, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__freq_step, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__amplitude_ref, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__amplitude_unit, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__amplitude_value, offset, length) = offset, get_array(get_u8)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'channel_tag' : __channel_tag, - 't' : __t, - 'freq_ref' : __freq_ref, - 'freq_step' : __freq_step, - 'amplitude_ref' : __amplitude_ref, - 'amplitude_unit' : __amplitude_unit, - 'amplitude_value' : __amplitude_value, - }, offset, length + ret = {} + (__channel_tag, offset, length) = get_u16(buf, offset, length) + ret['channel_tag'] = __channel_tag + (__t, offset, length) = GPSTime.parse_members(buf, offset, length) + ret['t'] = __t + (__freq_ref, offset, length) = get_f32(buf, offset, length) + ret['freq_ref'] = judicious_round(nb.f4(__freq_ref)) if SBP.judicious_rounding else __freq_ref + (__freq_step, offset, length) = get_f32(buf, offset, length) + ret['freq_step'] = judicious_round(nb.f4(__freq_step)) if SBP.judicious_rounding else __freq_step + (__amplitude_ref, offset, length) = get_f32(buf, offset, length) + ret['amplitude_ref'] = judicious_round(nb.f4(__amplitude_ref)) if SBP.judicious_rounding else __amplitude_ref + (__amplitude_unit, offset, length) = get_f32(buf, offset, length) + ret['amplitude_unit'] = judicious_round(nb.f4(__amplitude_unit)) if SBP.judicious_rounding else __amplitude_unit + (__amplitude_value, offset, length) = get_array(get_u8)(buf, offset, length) + ret['amplitude_value'] = __amplitude_value + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1178,6 +1280,25 @@ def _unpack_members(self, buf, offset, length): self.amplitude_unit = res['amplitude_unit'] self.amplitude_value = res['amplitude_value'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # channel_tag: u16 + ret += 2 + # t: GPSTime + ret += GPSTime._payload_size() + # freq_ref: float + ret += 4 + # freq_step: float + ret += 4 + # amplitude_ref: float + ret += 4 + # amplitude_unit: float + ret += 4 + # amplitude_value: array of u8 + ret += 247 + return ret SBP_MSG_FRONT_END_GAIN = 0x00BF class MsgFrontEndGain(SBP): @@ -1202,17 +1323,12 @@ class MsgFrontEndGain(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__rf_gain, offset, length) = offset, get_fixed_array(get_u8, 8, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__if_gain, offset, length) = offset, get_fixed_array(get_u8, 8, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'rf_gain' : __rf_gain, - 'if_gain' : __if_gain, - }, offset, length + ret = {} + (__rf_gain, offset, length) = get_fixed_array(get_s8, 8, 1)(buf, offset, length) + ret['rf_gain'] = __rf_gain + (__if_gain, offset, length) = get_fixed_array(get_s8, 8, 1)(buf, offset, length) + ret['if_gain'] = __if_gain + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -1221,6 +1337,15 @@ def _unpack_members(self, buf, offset, length): self.rf_gain = res['rf_gain'] self.if_gain = res['if_gain'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # rf_gain: array of s8 + ret += 1 * 8 + # if_gain: array of s8 + ret += 1 * 8 + return ret msg_classes = { diff --git a/python/sbp/jit/sbas.py b/python/sbp/jit/sbas.py index 73d499bfb7..44a8641d22 100644 --- a/python/sbp/jit/sbas.py +++ b/python/sbp/jit/sbas.py @@ -16,11 +16,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array from sbp.jit.gnss import * @@ -47,25 +49,16 @@ class MsgSbasRaw(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__message_type, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__data, offset, length) = offset, get_fixed_array(get_u8, 27, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sid' : __sid, - 'tow' : __tow, - 'message_type' : __message_type, - 'data' : __data, - }, offset, length + ret = {} + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__message_type, offset, length) = get_u8(buf, offset, length) + ret['message_type'] = __message_type + (__data, offset, length) = get_fixed_array(get_u8, 27, 1)(buf, offset, length) + ret['data'] = __data + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -76,6 +69,19 @@ def _unpack_members(self, buf, offset, length): self.message_type = res['message_type'] self.data = res['data'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sid: GnssSignal + ret += GnssSignal._payload_size() + # tow: u32 + ret += 4 + # message_type: u8 + ret += 1 + # data: array of u8 + ret += 1 * 27 + return ret msg_classes = { diff --git a/python/sbp/jit/settings.py b/python/sbp/jit/settings.py index 637658cb51..34775f9ee8 100644 --- a/python/sbp/jit/settings.py +++ b/python/sbp/jit/settings.py @@ -42,11 +42,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array # Automatically generated from piksi/yaml/swiftnav/sbp/settings.yaml with generate.py. @@ -66,6 +68,11 @@ class MsgSettingsSave(SBP): """ __slots__ = [] + def _unpack_members(self, buf, offset, length): + return {}, offset, length + + def _payload_size(self): + return 0 SBP_MSG_SETTINGS_WRITE = 0x00A0 class MsgSettingsWrite(SBP): @@ -90,13 +97,10 @@ class MsgSettingsWrite(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__setting, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'setting' : __setting, - }, offset, length + ret = {} + (__setting, offset, length) = get_setting(buf, offset, length) + ret['setting'] = __setting + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -104,6 +108,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.setting = res['setting'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # setting: string + ret += 247 + return ret SBP_MSG_SETTINGS_WRITE_RESP = 0x00AF class MsgSettingsWriteResp(SBP): @@ -129,17 +140,12 @@ class MsgSettingsWriteResp(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__status, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__setting, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'status' : __status, - 'setting' : __setting, - }, offset, length + ret = {} + (__status, offset, length) = get_u8(buf, offset, length) + ret['status'] = __status + (__setting, offset, length) = get_setting(buf, offset, length) + ret['setting'] = __setting + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -148,6 +154,15 @@ def _unpack_members(self, buf, offset, length): self.status = res['status'] self.setting = res['setting'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # status: u8 + ret += 1 + # setting: string + ret += 247 + return ret SBP_MSG_SETTINGS_READ_REQ = 0x00A4 class MsgSettingsReadReq(SBP): @@ -173,13 +188,10 @@ class MsgSettingsReadReq(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__setting, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'setting' : __setting, - }, offset, length + ret = {} + (__setting, offset, length) = get_setting(buf, offset, length) + ret['setting'] = __setting + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -187,6 +199,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.setting = res['setting'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # setting: string + ret += 247 + return ret SBP_MSG_SETTINGS_READ_RESP = 0x00A5 class MsgSettingsReadResp(SBP): @@ -211,13 +230,10 @@ class MsgSettingsReadResp(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__setting, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'setting' : __setting, - }, offset, length + ret = {} + (__setting, offset, length) = get_setting(buf, offset, length) + ret['setting'] = __setting + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -225,6 +241,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.setting = res['setting'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # setting: string + ret += 247 + return ret SBP_MSG_SETTINGS_READ_BY_INDEX_REQ = 0x00A2 class MsgSettingsReadByIndexReq(SBP): @@ -245,13 +268,10 @@ class MsgSettingsReadByIndexReq(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__index, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'index' : __index, - }, offset, length + ret = {} + (__index, offset, length) = get_u16(buf, offset, length) + ret['index'] = __index + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -259,6 +279,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.index = res['index'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # index: u16 + ret += 2 + return ret SBP_MSG_SETTINGS_READ_BY_INDEX_RESP = 0x00A7 class MsgSettingsReadByIndexResp(SBP): @@ -287,17 +314,12 @@ class MsgSettingsReadByIndexResp(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__index, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__setting, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'index' : __index, - 'setting' : __setting, - }, offset, length + ret = {} + (__index, offset, length) = get_u16(buf, offset, length) + ret['index'] = __index + (__setting, offset, length) = get_setting(buf, offset, length) + ret['setting'] = __setting + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -306,6 +328,15 @@ def _unpack_members(self, buf, offset, length): self.index = res['index'] self.setting = res['setting'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # index: u16 + ret += 2 + # setting: string + ret += 247 + return ret SBP_MSG_SETTINGS_READ_BY_INDEX_DONE = 0x00A6 class MsgSettingsReadByIndexDone(SBP): @@ -321,6 +352,11 @@ class MsgSettingsReadByIndexDone(SBP): """ __slots__ = [] + def _unpack_members(self, buf, offset, length): + return {}, offset, length + + def _payload_size(self): + return 0 SBP_MSG_SETTINGS_REGISTER = 0x00AE class MsgSettingsRegister(SBP): @@ -341,13 +377,10 @@ class MsgSettingsRegister(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__setting, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'setting' : __setting, - }, offset, length + ret = {} + (__setting, offset, length) = get_setting(buf, offset, length) + ret['setting'] = __setting + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -355,6 +388,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.setting = res['setting'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # setting: string + ret += 247 + return ret SBP_MSG_SETTINGS_REGISTER_RESP = 0x01AF class MsgSettingsRegisterResp(SBP): @@ -377,17 +417,12 @@ class MsgSettingsRegisterResp(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__status, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__setting, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'status' : __status, - 'setting' : __setting, - }, offset, length + ret = {} + (__status, offset, length) = get_u8(buf, offset, length) + ret['status'] = __status + (__setting, offset, length) = get_setting(buf, offset, length) + ret['setting'] = __setting + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -396,6 +431,15 @@ def _unpack_members(self, buf, offset, length): self.status = res['status'] self.setting = res['setting'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # status: u8 + ret += 1 + # setting: string + ret += 247 + return ret msg_classes = { diff --git a/python/sbp/jit/ssr.py b/python/sbp/jit/ssr.py index 671955ea95..47808affdf 100644 --- a/python/sbp/jit/ssr.py +++ b/python/sbp/jit/ssr.py @@ -16,11 +16,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array from sbp.jit.gnss import * @@ -44,17 +46,12 @@ class CodeBiasesContent(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__code, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__value, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'code' : __code, - 'value' : __value, - }, offset, length + ret = {} + (__code, offset, length) = get_u8(buf, offset, length) + ret['code'] = __code + (__value, offset, length) = get_s16(buf, offset, length) + ret['value'] = __value + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -63,6 +60,15 @@ def _unpack_members(self, buf, offset, length): self.code = res['code'] self.value = res['value'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # code: u8 + ret += 1 + # value: s16 + ret += 2 + return ret class PhaseBiasesContent(object): """SBP class for message PhaseBiasesContent @@ -85,29 +91,18 @@ class PhaseBiasesContent(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__code, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__integer_indicator, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__widelane_integer_indicator, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__discontinuity_counter, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__bias, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'code' : __code, - 'integer_indicator' : __integer_indicator, - 'widelane_integer_indicator' : __widelane_integer_indicator, - 'discontinuity_counter' : __discontinuity_counter, - 'bias' : __bias, - }, offset, length + ret = {} + (__code, offset, length) = get_u8(buf, offset, length) + ret['code'] = __code + (__integer_indicator, offset, length) = get_u8(buf, offset, length) + ret['integer_indicator'] = __integer_indicator + (__widelane_integer_indicator, offset, length) = get_u8(buf, offset, length) + ret['widelane_integer_indicator'] = __widelane_integer_indicator + (__discontinuity_counter, offset, length) = get_u8(buf, offset, length) + ret['discontinuity_counter'] = __discontinuity_counter + (__bias, offset, length) = get_s32(buf, offset, length) + ret['bias'] = __bias + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -119,6 +114,21 @@ def _unpack_members(self, buf, offset, length): self.discontinuity_counter = res['discontinuity_counter'] self.bias = res['bias'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # code: u8 + ret += 1 + # integer_indicator: u8 + ret += 1 + # widelane_integer_indicator: u8 + ret += 1 + # discontinuity_counter: u8 + ret += 1 + # bias: s32 + ret += 4 + return ret SBP_MSG_SSR_ORBIT_CLOCK = 0x05DD class MsgSsrOrbitClock(SBP): @@ -153,65 +163,36 @@ class MsgSsrOrbitClock(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__time, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__update_interval, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iod_ssr, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iod, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__radial, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__along, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cross, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__dot_radial, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__dot_along, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__dot_cross, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c0, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c1, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c2, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'time' : __time, - 'sid' : __sid, - 'update_interval' : __update_interval, - 'iod_ssr' : __iod_ssr, - 'iod' : __iod, - 'radial' : __radial, - 'along' : __along, - 'cross' : __cross, - 'dot_radial' : __dot_radial, - 'dot_along' : __dot_along, - 'dot_cross' : __dot_cross, - 'c0' : __c0, - 'c1' : __c1, - 'c2' : __c2, - }, offset, length + ret = {} + (__time, offset, length) = GPSTimeSec.parse_members(buf, offset, length) + ret['time'] = __time + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + (__update_interval, offset, length) = get_u8(buf, offset, length) + ret['update_interval'] = __update_interval + (__iod_ssr, offset, length) = get_u8(buf, offset, length) + ret['iod_ssr'] = __iod_ssr + (__iod, offset, length) = get_u32(buf, offset, length) + ret['iod'] = __iod + (__radial, offset, length) = get_s32(buf, offset, length) + ret['radial'] = __radial + (__along, offset, length) = get_s32(buf, offset, length) + ret['along'] = __along + (__cross, offset, length) = get_s32(buf, offset, length) + ret['cross'] = __cross + (__dot_radial, offset, length) = get_s32(buf, offset, length) + ret['dot_radial'] = __dot_radial + (__dot_along, offset, length) = get_s32(buf, offset, length) + ret['dot_along'] = __dot_along + (__dot_cross, offset, length) = get_s32(buf, offset, length) + ret['dot_cross'] = __dot_cross + (__c0, offset, length) = get_s32(buf, offset, length) + ret['c0'] = __c0 + (__c1, offset, length) = get_s32(buf, offset, length) + ret['c1'] = __c1 + (__c2, offset, length) = get_s32(buf, offset, length) + ret['c2'] = __c2 + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -232,6 +213,39 @@ def _unpack_members(self, buf, offset, length): self.c1 = res['c1'] self.c2 = res['c2'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # time: GPSTimeSec + ret += GPSTimeSec._payload_size() + # sid: GnssSignal + ret += GnssSignal._payload_size() + # update_interval: u8 + ret += 1 + # iod_ssr: u8 + ret += 1 + # iod: u32 + ret += 4 + # radial: s32 + ret += 4 + # along: s32 + ret += 4 + # cross: s32 + ret += 4 + # dot_radial: s32 + ret += 4 + # dot_along: s32 + ret += 4 + # dot_cross: s32 + ret += 4 + # c0: s32 + ret += 4 + # c1: s32 + ret += 4 + # c2: s32 + ret += 4 + return ret SBP_MSG_SSR_ORBIT_CLOCK_DEP_A = 0x05DC class MsgSsrOrbitClockDepA(SBP): @@ -266,65 +280,36 @@ class MsgSsrOrbitClockDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__time, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__update_interval, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iod_ssr, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iod, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__radial, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__along, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cross, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__dot_radial, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__dot_along, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__dot_cross, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c0, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c1, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__c2, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'time' : __time, - 'sid' : __sid, - 'update_interval' : __update_interval, - 'iod_ssr' : __iod_ssr, - 'iod' : __iod, - 'radial' : __radial, - 'along' : __along, - 'cross' : __cross, - 'dot_radial' : __dot_radial, - 'dot_along' : __dot_along, - 'dot_cross' : __dot_cross, - 'c0' : __c0, - 'c1' : __c1, - 'c2' : __c2, - }, offset, length + ret = {} + (__time, offset, length) = GPSTimeSec.parse_members(buf, offset, length) + ret['time'] = __time + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + (__update_interval, offset, length) = get_u8(buf, offset, length) + ret['update_interval'] = __update_interval + (__iod_ssr, offset, length) = get_u8(buf, offset, length) + ret['iod_ssr'] = __iod_ssr + (__iod, offset, length) = get_u8(buf, offset, length) + ret['iod'] = __iod + (__radial, offset, length) = get_s32(buf, offset, length) + ret['radial'] = __radial + (__along, offset, length) = get_s32(buf, offset, length) + ret['along'] = __along + (__cross, offset, length) = get_s32(buf, offset, length) + ret['cross'] = __cross + (__dot_radial, offset, length) = get_s32(buf, offset, length) + ret['dot_radial'] = __dot_radial + (__dot_along, offset, length) = get_s32(buf, offset, length) + ret['dot_along'] = __dot_along + (__dot_cross, offset, length) = get_s32(buf, offset, length) + ret['dot_cross'] = __dot_cross + (__c0, offset, length) = get_s32(buf, offset, length) + ret['c0'] = __c0 + (__c1, offset, length) = get_s32(buf, offset, length) + ret['c1'] = __c1 + (__c2, offset, length) = get_s32(buf, offset, length) + ret['c2'] = __c2 + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -345,6 +330,39 @@ def _unpack_members(self, buf, offset, length): self.c1 = res['c1'] self.c2 = res['c2'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # time: GPSTimeSec + ret += GPSTimeSec._payload_size() + # sid: GnssSignal + ret += GnssSignal._payload_size() + # update_interval: u8 + ret += 1 + # iod_ssr: u8 + ret += 1 + # iod: u8 + ret += 1 + # radial: s32 + ret += 4 + # along: s32 + ret += 4 + # cross: s32 + ret += 4 + # dot_radial: s32 + ret += 4 + # dot_along: s32 + ret += 4 + # dot_cross: s32 + ret += 4 + # c0: s32 + ret += 4 + # c1: s32 + ret += 4 + # c2: s32 + ret += 4 + return ret SBP_MSG_SSR_CODE_BIASES = 0x05E1 class MsgSsrCodeBiases(SBP): @@ -370,29 +388,18 @@ class MsgSsrCodeBiases(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__time, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__update_interval, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iod_ssr, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__biases, offset, length) = offset, get_array(CodeBiasesContent.parse_members)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'time' : __time, - 'sid' : __sid, - 'update_interval' : __update_interval, - 'iod_ssr' : __iod_ssr, - 'biases' : __biases, - }, offset, length + ret = {} + (__time, offset, length) = GPSTimeSec.parse_members(buf, offset, length) + ret['time'] = __time + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + (__update_interval, offset, length) = get_u8(buf, offset, length) + ret['update_interval'] = __update_interval + (__iod_ssr, offset, length) = get_u8(buf, offset, length) + ret['iod_ssr'] = __iod_ssr + (__biases, offset, length) = get_array(CodeBiasesContent.parse_members)(buf, offset, length) + ret['biases'] = __biases + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -404,6 +411,21 @@ def _unpack_members(self, buf, offset, length): self.iod_ssr = res['iod_ssr'] self.biases = res['biases'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # time: GPSTimeSec + ret += GPSTimeSec._payload_size() + # sid: GnssSignal + ret += GnssSignal._payload_size() + # update_interval: u8 + ret += 1 + # iod_ssr: u8 + ret += 1 + # biases: array of CodeBiasesContent + ret += 247 + return ret SBP_MSG_SSR_PHASE_BIASES = 0x05E6 class MsgSsrPhaseBiases(SBP): @@ -435,45 +457,26 @@ class MsgSsrPhaseBiases(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__time, offset, length) = offset, GPSTimeSec.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__update_interval, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__iod_ssr, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__dispersive_bias, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__mw_consistency, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__yaw, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__yaw_rate, offset, length) = offset, get_s8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__biases, offset, length) = offset, get_array(PhaseBiasesContent.parse_members)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'time' : __time, - 'sid' : __sid, - 'update_interval' : __update_interval, - 'iod_ssr' : __iod_ssr, - 'dispersive_bias' : __dispersive_bias, - 'mw_consistency' : __mw_consistency, - 'yaw' : __yaw, - 'yaw_rate' : __yaw_rate, - 'biases' : __biases, - }, offset, length + ret = {} + (__time, offset, length) = GPSTimeSec.parse_members(buf, offset, length) + ret['time'] = __time + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + (__update_interval, offset, length) = get_u8(buf, offset, length) + ret['update_interval'] = __update_interval + (__iod_ssr, offset, length) = get_u8(buf, offset, length) + ret['iod_ssr'] = __iod_ssr + (__dispersive_bias, offset, length) = get_u8(buf, offset, length) + ret['dispersive_bias'] = __dispersive_bias + (__mw_consistency, offset, length) = get_u8(buf, offset, length) + ret['mw_consistency'] = __mw_consistency + (__yaw, offset, length) = get_u16(buf, offset, length) + ret['yaw'] = __yaw + (__yaw_rate, offset, length) = get_s8(buf, offset, length) + ret['yaw_rate'] = __yaw_rate + (__biases, offset, length) = get_array(PhaseBiasesContent.parse_members)(buf, offset, length) + ret['biases'] = __biases + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -489,6 +492,29 @@ def _unpack_members(self, buf, offset, length): self.yaw_rate = res['yaw_rate'] self.biases = res['biases'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # time: GPSTimeSec + ret += GPSTimeSec._payload_size() + # sid: GnssSignal + ret += GnssSignal._payload_size() + # update_interval: u8 + ret += 1 + # iod_ssr: u8 + ret += 1 + # dispersive_bias: u8 + ret += 1 + # mw_consistency: u8 + ret += 1 + # yaw: u16 + ret += 2 + # yaw_rate: s8 + ret += 1 + # biases: array of PhaseBiasesContent + ret += 247 + return ret msg_classes = { diff --git a/python/sbp/jit/system.py b/python/sbp/jit/system.py index ff3d0d4416..670601d1d4 100644 --- a/python/sbp/jit/system.py +++ b/python/sbp/jit/system.py @@ -16,11 +16,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array # Automatically generated from piksi/yaml/swiftnav/sbp/system.yaml with generate.py. @@ -47,21 +49,14 @@ class MsgStartup(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__cause, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__startup_type, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__reserved, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'cause' : __cause, - 'startup_type' : __startup_type, - 'reserved' : __reserved, - }, offset, length + ret = {} + (__cause, offset, length) = get_u8(buf, offset, length) + ret['cause'] = __cause + (__startup_type, offset, length) = get_u8(buf, offset, length) + ret['startup_type'] = __startup_type + (__reserved, offset, length) = get_u16(buf, offset, length) + ret['reserved'] = __reserved + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -71,6 +66,17 @@ def _unpack_members(self, buf, offset, length): self.startup_type = res['startup_type'] self.reserved = res['reserved'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # cause: u8 + ret += 1 + # startup_type: u8 + ret += 1 + # reserved: u16 + ret += 2 + return ret SBP_MSG_DGNSS_STATUS = 0xFF02 class MsgDgnssStatus(SBP): @@ -94,25 +100,16 @@ class MsgDgnssStatus(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__latency, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__num_signals, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__source, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'flags' : __flags, - 'latency' : __latency, - 'num_signals' : __num_signals, - 'source' : __source, - }, offset, length + ret = {} + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + (__latency, offset, length) = get_u16(buf, offset, length) + ret['latency'] = __latency + (__num_signals, offset, length) = get_u8(buf, offset, length) + ret['num_signals'] = __num_signals + (__source, offset, length) = get_string(buf, offset, length) + ret['source'] = __source + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -123,6 +120,19 @@ def _unpack_members(self, buf, offset, length): self.num_signals = res['num_signals'] self.source = res['source'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # flags: u8 + ret += 1 + # latency: u16 + ret += 2 + # num_signals: u8 + ret += 1 + # source: string + ret += 247 + return ret SBP_MSG_HEARTBEAT = 0xFFFF class MsgHeartbeat(SBP): @@ -150,13 +160,10 @@ class MsgHeartbeat(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__flags, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'flags' : __flags, - }, offset, length + ret = {} + (__flags, offset, length) = get_u32(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -164,6 +171,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # flags: u32 + ret += 4 + return ret SBP_MSG_INS_STATUS = 0xFF03 class MsgInsStatus(SBP): @@ -183,13 +197,10 @@ class MsgInsStatus(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__flags, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'flags' : __flags, - }, offset, length + ret = {} + (__flags, offset, length) = get_u32(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -197,6 +208,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # flags: u32 + ret += 4 + return ret SBP_MSG_CSAC_TELEMETRY = 0xFF04 class MsgCsacTelemetry(SBP): @@ -218,17 +236,12 @@ class MsgCsacTelemetry(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__id, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__telemetry, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'id' : __id, - 'telemetry' : __telemetry, - }, offset, length + ret = {} + (__id, offset, length) = get_u8(buf, offset, length) + ret['id'] = __id + (__telemetry, offset, length) = get_string(buf, offset, length) + ret['telemetry'] = __telemetry + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -237,6 +250,15 @@ def _unpack_members(self, buf, offset, length): self.id = res['id'] self.telemetry = res['telemetry'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # id: u8 + ret += 1 + # telemetry: string + ret += 247 + return ret SBP_MSG_CSAC_TELEMETRY_LABELS = 0xFF05 class MsgCsacTelemetryLabels(SBP): @@ -258,17 +280,12 @@ class MsgCsacTelemetryLabels(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__id, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__telemetry_labels, offset, length) = offset, get_string(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'id' : __id, - 'telemetry_labels' : __telemetry_labels, - }, offset, length + ret = {} + (__id, offset, length) = get_u8(buf, offset, length) + ret['id'] = __id + (__telemetry_labels, offset, length) = get_string(buf, offset, length) + ret['telemetry_labels'] = __telemetry_labels + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -277,6 +294,15 @@ def _unpack_members(self, buf, offset, length): self.id = res['id'] self.telemetry_labels = res['telemetry_labels'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # id: u8 + ret += 1 + # telemetry_labels: string + ret += 247 + return ret msg_classes = { diff --git a/python/sbp/jit/tracking.py b/python/sbp/jit/tracking.py index 497a8111eb..09245d1cad 100644 --- a/python/sbp/jit/tracking.py +++ b/python/sbp/jit/tracking.py @@ -17,11 +17,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array from sbp.jit.gnss import * @@ -65,93 +67,50 @@ class MsgTrackingStateDetailedDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__recv_time, offset, length) = offset, get_u64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tot, offset, length) = offset, GPSTime.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__P, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__P_std, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__L, offset, length) = offset, CarrierPhase.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cn0, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__lock, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__doppler, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__doppler_std, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__uptime, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__clock_offset, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__clock_drift, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__corr_spacing, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__acceleration, offset, length) = offset, get_s8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sync_flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tow_flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__track_flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__nav_flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pset_flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__misc_flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'recv_time' : __recv_time, - 'tot' : __tot, - 'P' : __P, - 'P_std' : __P_std, - 'L' : __L, - 'cn0' : __cn0, - 'lock' : __lock, - 'sid' : __sid, - 'doppler' : __doppler, - 'doppler_std' : __doppler_std, - 'uptime' : __uptime, - 'clock_offset' : __clock_offset, - 'clock_drift' : __clock_drift, - 'corr_spacing' : __corr_spacing, - 'acceleration' : __acceleration, - 'sync_flags' : __sync_flags, - 'tow_flags' : __tow_flags, - 'track_flags' : __track_flags, - 'nav_flags' : __nav_flags, - 'pset_flags' : __pset_flags, - 'misc_flags' : __misc_flags, - }, offset, length + ret = {} + (__recv_time, offset, length) = get_u64(buf, offset, length) + ret['recv_time'] = __recv_time + (__tot, offset, length) = GPSTime.parse_members(buf, offset, length) + ret['tot'] = __tot + (__P, offset, length) = get_u32(buf, offset, length) + ret['P'] = __P + (__P_std, offset, length) = get_u16(buf, offset, length) + ret['P_std'] = __P_std + (__L, offset, length) = CarrierPhase.parse_members(buf, offset, length) + ret['L'] = __L + (__cn0, offset, length) = get_u8(buf, offset, length) + ret['cn0'] = __cn0 + (__lock, offset, length) = get_u16(buf, offset, length) + ret['lock'] = __lock + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + (__doppler, offset, length) = get_s32(buf, offset, length) + ret['doppler'] = __doppler + (__doppler_std, offset, length) = get_u16(buf, offset, length) + ret['doppler_std'] = __doppler_std + (__uptime, offset, length) = get_u32(buf, offset, length) + ret['uptime'] = __uptime + (__clock_offset, offset, length) = get_s16(buf, offset, length) + ret['clock_offset'] = __clock_offset + (__clock_drift, offset, length) = get_s16(buf, offset, length) + ret['clock_drift'] = __clock_drift + (__corr_spacing, offset, length) = get_u16(buf, offset, length) + ret['corr_spacing'] = __corr_spacing + (__acceleration, offset, length) = get_s8(buf, offset, length) + ret['acceleration'] = __acceleration + (__sync_flags, offset, length) = get_u8(buf, offset, length) + ret['sync_flags'] = __sync_flags + (__tow_flags, offset, length) = get_u8(buf, offset, length) + ret['tow_flags'] = __tow_flags + (__track_flags, offset, length) = get_u8(buf, offset, length) + ret['track_flags'] = __track_flags + (__nav_flags, offset, length) = get_u8(buf, offset, length) + ret['nav_flags'] = __nav_flags + (__pset_flags, offset, length) = get_u8(buf, offset, length) + ret['pset_flags'] = __pset_flags + (__misc_flags, offset, length) = get_u8(buf, offset, length) + ret['misc_flags'] = __misc_flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -179,6 +138,53 @@ def _unpack_members(self, buf, offset, length): self.pset_flags = res['pset_flags'] self.misc_flags = res['misc_flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # recv_time: u64 + ret += 8 + # tot: GPSTime + ret += GPSTime._payload_size() + # P: u32 + ret += 4 + # P_std: u16 + ret += 2 + # L: CarrierPhase + ret += CarrierPhase._payload_size() + # cn0: u8 + ret += 1 + # lock: u16 + ret += 2 + # sid: GnssSignal + ret += GnssSignal._payload_size() + # doppler: s32 + ret += 4 + # doppler_std: u16 + ret += 2 + # uptime: u32 + ret += 4 + # clock_offset: s16 + ret += 2 + # clock_drift: s16 + ret += 2 + # corr_spacing: u16 + ret += 2 + # acceleration: s8 + ret += 1 + # sync_flags: u8 + ret += 1 + # tow_flags: u8 + ret += 1 + # track_flags: u8 + ret += 1 + # nav_flags: u8 + ret += 1 + # pset_flags: u8 + ret += 1 + # misc_flags: u8 + ret += 1 + return ret SBP_MSG_TRACKING_STATE_DETAILED_DEP = 0x0011 class MsgTrackingStateDetailedDep(SBP): @@ -216,93 +222,50 @@ class MsgTrackingStateDetailedDep(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__recv_time, offset, length) = offset, get_u64(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tot, offset, length) = offset, GPSTimeDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__P, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__P_std, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__L, offset, length) = offset, CarrierPhase.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cn0, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__lock, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__doppler, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__doppler_std, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__uptime, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__clock_offset, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__clock_drift, offset, length) = offset, get_s16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__corr_spacing, offset, length) = offset, get_u16(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__acceleration, offset, length) = offset, get_s8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sync_flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__tow_flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__track_flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__nav_flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__pset_flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__misc_flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'recv_time' : __recv_time, - 'tot' : __tot, - 'P' : __P, - 'P_std' : __P_std, - 'L' : __L, - 'cn0' : __cn0, - 'lock' : __lock, - 'sid' : __sid, - 'doppler' : __doppler, - 'doppler_std' : __doppler_std, - 'uptime' : __uptime, - 'clock_offset' : __clock_offset, - 'clock_drift' : __clock_drift, - 'corr_spacing' : __corr_spacing, - 'acceleration' : __acceleration, - 'sync_flags' : __sync_flags, - 'tow_flags' : __tow_flags, - 'track_flags' : __track_flags, - 'nav_flags' : __nav_flags, - 'pset_flags' : __pset_flags, - 'misc_flags' : __misc_flags, - }, offset, length + ret = {} + (__recv_time, offset, length) = get_u64(buf, offset, length) + ret['recv_time'] = __recv_time + (__tot, offset, length) = GPSTimeDep.parse_members(buf, offset, length) + ret['tot'] = __tot + (__P, offset, length) = get_u32(buf, offset, length) + ret['P'] = __P + (__P_std, offset, length) = get_u16(buf, offset, length) + ret['P_std'] = __P_std + (__L, offset, length) = CarrierPhase.parse_members(buf, offset, length) + ret['L'] = __L + (__cn0, offset, length) = get_u8(buf, offset, length) + ret['cn0'] = __cn0 + (__lock, offset, length) = get_u16(buf, offset, length) + ret['lock'] = __lock + (__sid, offset, length) = GnssSignalDep.parse_members(buf, offset, length) + ret['sid'] = __sid + (__doppler, offset, length) = get_s32(buf, offset, length) + ret['doppler'] = __doppler + (__doppler_std, offset, length) = get_u16(buf, offset, length) + ret['doppler_std'] = __doppler_std + (__uptime, offset, length) = get_u32(buf, offset, length) + ret['uptime'] = __uptime + (__clock_offset, offset, length) = get_s16(buf, offset, length) + ret['clock_offset'] = __clock_offset + (__clock_drift, offset, length) = get_s16(buf, offset, length) + ret['clock_drift'] = __clock_drift + (__corr_spacing, offset, length) = get_u16(buf, offset, length) + ret['corr_spacing'] = __corr_spacing + (__acceleration, offset, length) = get_s8(buf, offset, length) + ret['acceleration'] = __acceleration + (__sync_flags, offset, length) = get_u8(buf, offset, length) + ret['sync_flags'] = __sync_flags + (__tow_flags, offset, length) = get_u8(buf, offset, length) + ret['tow_flags'] = __tow_flags + (__track_flags, offset, length) = get_u8(buf, offset, length) + ret['track_flags'] = __track_flags + (__nav_flags, offset, length) = get_u8(buf, offset, length) + ret['nav_flags'] = __nav_flags + (__pset_flags, offset, length) = get_u8(buf, offset, length) + ret['pset_flags'] = __pset_flags + (__misc_flags, offset, length) = get_u8(buf, offset, length) + ret['misc_flags'] = __misc_flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -330,6 +293,53 @@ def _unpack_members(self, buf, offset, length): self.pset_flags = res['pset_flags'] self.misc_flags = res['misc_flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # recv_time: u64 + ret += 8 + # tot: GPSTimeDep + ret += GPSTimeDep._payload_size() + # P: u32 + ret += 4 + # P_std: u16 + ret += 2 + # L: CarrierPhase + ret += CarrierPhase._payload_size() + # cn0: u8 + ret += 1 + # lock: u16 + ret += 2 + # sid: GnssSignalDep + ret += GnssSignalDep._payload_size() + # doppler: s32 + ret += 4 + # doppler_std: u16 + ret += 2 + # uptime: u32 + ret += 4 + # clock_offset: s16 + ret += 2 + # clock_drift: s16 + ret += 2 + # corr_spacing: u16 + ret += 2 + # acceleration: s8 + ret += 1 + # sync_flags: u8 + ret += 1 + # tow_flags: u8 + ret += 1 + # track_flags: u8 + ret += 1 + # nav_flags: u8 + ret += 1 + # pset_flags: u8 + ret += 1 + # misc_flags: u8 + ret += 1 + return ret class TrackingChannelState(object): """SBP class for message TrackingChannelState @@ -350,21 +360,14 @@ class TrackingChannelState(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__fcn, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cn0, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'sid' : __sid, - 'fcn' : __fcn, - 'cn0' : __cn0, - }, offset, length + ret = {} + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + (__fcn, offset, length) = get_u8(buf, offset, length) + ret['fcn'] = __fcn + (__cn0, offset, length) = get_u8(buf, offset, length) + ret['cn0'] = __cn0 + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -374,6 +377,17 @@ def _unpack_members(self, buf, offset, length): self.fcn = res['fcn'] self.cn0 = res['cn0'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # sid: GnssSignal + ret += GnssSignal._payload_size() + # fcn: u8 + ret += 1 + # cn0: u8 + ret += 1 + return ret SBP_MSG_TRACKING_STATE = 0x0041 class MsgTrackingState(SBP): @@ -394,13 +408,10 @@ class MsgTrackingState(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__states, offset, length) = offset, get_array(TrackingChannelState.parse_members)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'states' : __states, - }, offset, length + ret = {} + (__states, offset, length) = get_array(TrackingChannelState.parse_members)(buf, offset, length) + ret['states'] = __states + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -408,6 +419,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.states = res['states'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # states: array of TrackingChannelState + ret += 247 + return ret class MeasurementState(object): """SBP class for message MeasurementState @@ -417,10 +435,10 @@ class MeasurementState(object): of its fields. - Measurement Engine tracking channel state for a specific satellite signal -and measured signal power. -The mesid field for Glonass can either -carry the FCN as 100 + FCN where FCN is in [-7, +6] or + Measurement Engine tracking channel state for a specific satellite signal +and measured signal power. +The mesid field for Glonass can either +carry the FCN as 100 + FCN where FCN is in [-7, +6] or the Slot ID (from 1 to 28) @@ -430,17 +448,12 @@ class MeasurementState(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__mesid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cn0, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'mesid' : __mesid, - 'cn0' : __cn0, - }, offset, length + ret = {} + (__mesid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['mesid'] = __mesid + (__cn0, offset, length) = get_u8(buf, offset, length) + ret['cn0'] = __cn0 + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -449,6 +462,15 @@ def _unpack_members(self, buf, offset, length): self.mesid = res['mesid'] self.cn0 = res['cn0'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # mesid: GnssSignal + ret += GnssSignal._payload_size() + # cn0: u8 + ret += 1 + return ret SBP_MSG_MEASUREMENT_STATE = 0x0061 class MsgMeasurementState(SBP): @@ -469,13 +491,10 @@ class MsgMeasurementState(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__states, offset, length) = offset, get_array(MeasurementState.parse_members)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'states' : __states, - }, offset, length + ret = {} + (__states, offset, length) = get_array(MeasurementState.parse_members)(buf, offset, length) + ret['states'] = __states + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -483,6 +502,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.states = res['states'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # states: array of MeasurementState + ret += 247 + return ret class TrackingChannelCorrelation(object): """SBP class for message TrackingChannelCorrelation @@ -501,17 +527,12 @@ class TrackingChannelCorrelation(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__I, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__Q, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'I' : __I, - 'Q' : __Q, - }, offset, length + ret = {} + (__I, offset, length) = get_s16(buf, offset, length) + ret['I'] = __I + (__Q, offset, length) = get_s16(buf, offset, length) + ret['Q'] = __Q + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -520,10 +541,19 @@ def _unpack_members(self, buf, offset, length): self.I = res['I'] self.Q = res['Q'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # I: s16 + ret += 2 + # Q: s16 + ret += 2 + return ret -SBP_MSG_TRACKING_IQ = 0x002C +SBP_MSG_TRACKING_IQ = 0x002D class MsgTrackingIq(SBP): - """SBP class for message MSG_TRACKING_IQ (0x002C). + """SBP class for message MSG_TRACKING_IQ (0x002D). You can have MSG_TRACKING_IQ inherit its fields directly from an inherited SBP object, or construct it inline using a dict @@ -541,21 +571,104 @@ class MsgTrackingIq(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__channel, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignal.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__corrs, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'channel' : __channel, - 'sid' : __sid, - 'corrs' : __corrs, - }, offset, length + ret = {} + (__channel, offset, length) = get_u8(buf, offset, length) + ret['channel'] = __channel + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + (__corrs, offset, length) = get_fixed_array(TrackingChannelCorrelation._unpack_members, 3, TrackingChannelCorrelation._payload_size())(buf, offset, length) + ret['corrs'] = __corrs + return ret, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.channel = res['channel'] + self.sid = res['sid'] + self.corrs = res['corrs'] + return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # channel: u8 + ret += 1 + # sid: GnssSignal + ret += GnssSignal._payload_size() + # corrs: array of TrackingChannelCorrelation + ret += TrackingChannelCorrelation._payload_size() * 3 + return ret + +class TrackingChannelCorrelationDep(object): + """SBP class for message TrackingChannelCorrelationDep + + You can have TrackingChannelCorrelationDep inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Structure containing in-phase and quadrature correlation components. + + + """ + __slots__ = ['I', + 'Q', + ] + @classmethod + def parse_members(cls, buf, offset, length): + ret = {} + (__I, offset, length) = get_s32(buf, offset, length) + ret['I'] = __I + (__Q, offset, length) = get_s32(buf, offset, length) + ret['Q'] = __Q + return ret, offset, length + + def _unpack_members(self, buf, offset, length): + res, off, length = self.parse_members(buf, offset, length) + if off == offset: + return {}, offset, length + self.I = res['I'] + self.Q = res['Q'] + return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # I: s32 + ret += 4 + # Q: s32 + ret += 4 + return ret + +SBP_MSG_TRACKING_IQ_DEP_B = 0x002C +class MsgTrackingIqDepB(SBP): + """SBP class for message MSG_TRACKING_IQ_DEP_B (0x002C). + + You can have MSG_TRACKING_IQ_DEP_B inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + When enabled, a tracking channel can output the correlations at each +update interval. + + + """ + __slots__ = ['channel', + 'sid', + 'corrs', + ] + @classmethod + def parse_members(cls, buf, offset, length): + ret = {} + (__channel, offset, length) = get_u8(buf, offset, length) + ret['channel'] = __channel + (__sid, offset, length) = GnssSignal.parse_members(buf, offset, length) + ret['sid'] = __sid + (__corrs, offset, length) = get_fixed_array(TrackingChannelCorrelationDep._unpack_members, 3, TrackingChannelCorrelationDep._payload_size())(buf, offset, length) + ret['corrs'] = __corrs + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -565,12 +678,23 @@ def _unpack_members(self, buf, offset, length): self.sid = res['sid'] self.corrs = res['corrs'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # channel: u8 + ret += 1 + # sid: GnssSignal + ret += GnssSignal._payload_size() + # corrs: array of TrackingChannelCorrelationDep + ret += TrackingChannelCorrelationDep._payload_size() * 3 + return ret -SBP_MSG_TRACKING_IQ_DEP = 0x001C -class MsgTrackingIqDep(SBP): - """SBP class for message MSG_TRACKING_IQ_DEP (0x001C). +SBP_MSG_TRACKING_IQ_DEP_A = 0x001C +class MsgTrackingIqDepA(SBP): + """SBP class for message MSG_TRACKING_IQ_DEP_A (0x001C). - You can have MSG_TRACKING_IQ_DEP inherit its fields directly + You can have MSG_TRACKING_IQ_DEP_A inherit its fields directly from an inherited SBP object, or construct it inline using a dict of its fields. @@ -584,21 +708,14 @@ class MsgTrackingIqDep(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__channel, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__corrs, offset, length) = offset, get_fixed_array(get_u8, 3, 1)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'channel' : __channel, - 'sid' : __sid, - 'corrs' : __corrs, - }, offset, length + ret = {} + (__channel, offset, length) = get_u8(buf, offset, length) + ret['channel'] = __channel + (__sid, offset, length) = GnssSignalDep.parse_members(buf, offset, length) + ret['sid'] = __sid + (__corrs, offset, length) = get_fixed_array(TrackingChannelCorrelationDep._unpack_members, 3, TrackingChannelCorrelationDep._payload_size())(buf, offset, length) + ret['corrs'] = __corrs + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -608,6 +725,17 @@ def _unpack_members(self, buf, offset, length): self.sid = res['sid'] self.corrs = res['corrs'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # channel: u8 + ret += 1 + # sid: GnssSignalDep + ret += GnssSignalDep._payload_size() + # corrs: array of TrackingChannelCorrelationDep + ret += TrackingChannelCorrelationDep._payload_size() * 3 + return ret class TrackingChannelStateDepA(object): """SBP class for message TrackingChannelStateDepA @@ -626,21 +754,14 @@ class TrackingChannelStateDepA(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__state, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__prn, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cn0, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'state' : __state, - 'prn' : __prn, - 'cn0' : __cn0, - }, offset, length + ret = {} + (__state, offset, length) = get_u8(buf, offset, length) + ret['state'] = __state + (__prn, offset, length) = get_u8(buf, offset, length) + ret['prn'] = __prn + (__cn0, offset, length) = get_f32(buf, offset, length) + ret['cn0'] = judicious_round(nb.f4(__cn0)) if SBP.judicious_rounding else __cn0 + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -650,6 +771,17 @@ def _unpack_members(self, buf, offset, length): self.prn = res['prn'] self.cn0 = res['cn0'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # state: u8 + ret += 1 + # prn: u8 + ret += 1 + # cn0: float + ret += 4 + return ret SBP_MSG_TRACKING_STATE_DEP_A = 0x0016 class MsgTrackingStateDepA(SBP): @@ -667,13 +799,10 @@ class MsgTrackingStateDepA(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__states, offset, length) = offset, get_array(TrackingChannelStateDepA.parse_members)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'states' : __states, - }, offset, length + ret = {} + (__states, offset, length) = get_array(TrackingChannelStateDepA.parse_members)(buf, offset, length) + ret['states'] = __states + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -681,6 +810,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.states = res['states'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # states: array of TrackingChannelStateDepA + ret += 247 + return ret class TrackingChannelStateDepB(object): """SBP class for message TrackingChannelStateDepB @@ -699,21 +835,14 @@ class TrackingChannelStateDepB(object): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__state, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__sid, offset, length) = offset, GnssSignalDep.parse_members(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__cn0, offset, length) = offset, get_f32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'state' : __state, - 'sid' : __sid, - 'cn0' : __cn0, - }, offset, length + ret = {} + (__state, offset, length) = get_u8(buf, offset, length) + ret['state'] = __state + (__sid, offset, length) = GnssSignalDep.parse_members(buf, offset, length) + ret['sid'] = __sid + (__cn0, offset, length) = get_f32(buf, offset, length) + ret['cn0'] = judicious_round(nb.f4(__cn0)) if SBP.judicious_rounding else __cn0 + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -723,6 +852,17 @@ def _unpack_members(self, buf, offset, length): self.sid = res['sid'] self.cn0 = res['cn0'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # state: u8 + ret += 1 + # sid: GnssSignalDep + ret += GnssSignalDep._payload_size() + # cn0: float + ret += 4 + return ret SBP_MSG_TRACKING_STATE_DEP_B = 0x0013 class MsgTrackingStateDepB(SBP): @@ -740,13 +880,10 @@ class MsgTrackingStateDepB(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__states, offset, length) = offset, get_array(TrackingChannelStateDepB.parse_members)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'states' : __states, - }, offset, length + ret = {} + (__states, offset, length) = get_array(TrackingChannelStateDepB.parse_members)(buf, offset, length) + ret['states'] = __states + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -754,6 +891,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.states = res['states'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # states: array of TrackingChannelStateDepB + ret += 247 + return ret msg_classes = { @@ -761,8 +905,9 @@ def _unpack_members(self, buf, offset, length): 0x0011: MsgTrackingStateDetailedDep, 0x0041: MsgTrackingState, 0x0061: MsgMeasurementState, - 0x002C: MsgTrackingIq, - 0x001C: MsgTrackingIqDep, + 0x002D: MsgTrackingIq, + 0x002C: MsgTrackingIqDepB, + 0x001C: MsgTrackingIqDepA, 0x0016: MsgTrackingStateDepA, 0x0013: MsgTrackingStateDepB, } \ No newline at end of file diff --git a/python/sbp/jit/user.py b/python/sbp/jit/user.py index f1fdb63ce4..e9fa94aa63 100644 --- a/python/sbp/jit/user.py +++ b/python/sbp/jit/user.py @@ -17,11 +17,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array # Automatically generated from piksi/yaml/swiftnav/sbp/user.yaml with generate.py. @@ -44,13 +46,10 @@ class MsgUserData(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__contents, offset, length) = offset, get_array(get_u8)(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'contents' : __contents, - }, offset, length + ret = {} + (__contents, offset, length) = get_array(get_u8)(buf, offset, length) + ret['contents'] = __contents + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -58,6 +57,13 @@ def _unpack_members(self, buf, offset, length): return {}, offset, length self.contents = res['contents'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # contents: array of u8 + ret += 247 + return ret msg_classes = { diff --git a/python/sbp/jit/vehicle.py b/python/sbp/jit/vehicle.py index 1b2bd6c4f3..a4795b4771 100644 --- a/python/sbp/jit/vehicle.py +++ b/python/sbp/jit/vehicle.py @@ -16,11 +16,13 @@ import json +import numba as nb + from sbp.jit.msg import SBP, SENDER_ID from sbp.jit.msg import get_u8, get_u16, get_u32, get_u64 from sbp.jit.msg import get_s8, get_s16, get_s32, get_s64 -from sbp.jit.msg import get_f32, get_f64 -from sbp.jit.msg import get_string, get_fixed_string +from sbp.jit.msg import get_f32, get_f64, judicious_round +from sbp.jit.msg import get_string, get_fixed_string, get_setting from sbp.jit.msg import get_array, get_fixed_array # Automatically generated from piksi/yaml/swiftnav/sbp/vehicle.yaml with generate.py. @@ -48,21 +50,14 @@ class MsgOdometry(SBP): ] @classmethod def parse_members(cls, buf, offset, length): - o_0 = offset - o_1, (__tow, offset, length) = offset, get_u32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__velocity, offset, length) = offset, get_s32(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - o_1, (__flags, offset, length) = offset, get_u8(buf, offset, length) - if o_1 == offset: - return {}, o_0, length - return { - 'tow' : __tow, - 'velocity' : __velocity, - 'flags' : __flags, - }, offset, length + ret = {} + (__tow, offset, length) = get_u32(buf, offset, length) + ret['tow'] = __tow + (__velocity, offset, length) = get_s32(buf, offset, length) + ret['velocity'] = __velocity + (__flags, offset, length) = get_u8(buf, offset, length) + ret['flags'] = __flags + return ret, offset, length def _unpack_members(self, buf, offset, length): res, off, length = self.parse_members(buf, offset, length) @@ -72,6 +67,17 @@ def _unpack_members(self, buf, offset, length): self.velocity = res['velocity'] self.flags = res['flags'] return res, off, length + + @classmethod + def _payload_size(self): + ret = 0 + # tow: u32 + ret += 4 + # velocity: s32 + ret += 4 + # flags: u8 + ret += 1 + return ret msg_classes = {