├── test ├── __init__.py ├── test_rawmessage.py ├── test_utils.py ├── test_message_id.py ├── test_message_class.py ├── test_checksum.py └── test_descriptions.py ├── docs ├── requirements.txt ├── source │ ├── _static │ │ └── .gitignore │ ├── _templates │ │ └── .gitignore │ ├── index.rst │ └── conf.py ├── Makefile └── scripts │ └── generate_messages.py ├── requirements.txt ├── ubx ├── printing │ ├── __init__.py │ ├── base.py │ └── rst.py ├── syncchars.py ├── descriptions │ ├── log_erase.py │ ├── nav_resetodo.py │ ├── __init__.py │ ├── ack_ack.py │ ├── ack_nack.py │ ├── inf_test.py │ ├── inf_debug.py │ ├── inf_error.py │ ├── inf_notice.py │ ├── inf_warning.py │ ├── log_string.py │ ├── nav_eoe.py │ ├── cfg_rxm.py │ ├── tim_dosc.py │ ├── cfg_dgnss.py │ ├── cfg_hnr.py │ ├── mga_dbd.py │ ├── sec_uniqid.py │ ├── cfg_pwr.py │ ├── cfg_rate.py │ ├── mon_rxbuf.py │ ├── cfg_dynseed.py │ ├── log_retrieve.py │ ├── mon_rxr.py │ ├── mga_ack.py │ ├── nav_clock.py │ ├── nav_posecef.py │ ├── nav_velecef.py │ ├── sec_sign.py │ ├── cfg_pms.py │ ├── nav_odo.py │ ├── nav_posllh.py │ ├── log_retrievebatch.py │ ├── mon_batch.py │ ├── cfg_rinv.py │ ├── nav_dop.py │ ├── mon_msgpp.py │ ├── aid_aop.py │ ├── nav_aopstatus.py │ ├── rxm_rtcm.py │ ├── log_create.py │ ├── nav_velned.py │ ├── tim_svin.py │ ├── mga_ano.py │ ├── tim_hoc.py │ ├── nav_att.py │ ├── cfg_fixseed.py │ ├── tim_fchg.py │ ├── mon_hw2.py │ ├── tim_vrfy.py │ ├── nav_geofence.py │ ├── mon_ver.py │ ├── nav_hpposecef.py │ ├── nav_timeglo.py │ ├── aid_alm.py │ ├── mon_io.py │ ├── esf_raw.py │ ├── log_retrieveposextra.py │ ├── nav_timegps.py │ ├── rxm_sfrbx.py │ ├── log_retrievestring.py │ ├── nav_hpposllh.py │ ├── nav_timedbs.py │ ├── cfg_msg.py │ ├── aid_eph.py │ ├── nav_timegal.py │ ├── cfg_txslot.py │ ├── mon_txbuf.py │ ├── cfg_geofence.py │ ├── cfg_tmode2.py │ ├── cfg_logfilter.py │ ├── mon_patch.py │ ├── nav_svin.py │ ├── cfg_batch.py │ ├── cfg_usb.py │ ├── log_retrievepos.py │ ├── log_findtime.py │ ├── nav_timeutc.py │ ├── cfg_rst.py │ ├── cfg_inf.py │ ├── cfg_gnss.py │ ├── tim_tp.py │ ├── mga_flash.py │ ├── nav_timels.py │ ├── cfg_itfm.py │ ├── nav_dgps.py │ ├── rxm_rlm.py │ ├── cfg_ant.py │ ├── cfg_tmode3.py │ ├── cfg_dat.py │ ├── tim_vcocal.py │ ├── tim_tm2.py │ ├── tim_smeas.py │ ├── esf_ins.py │ ├── cfg_odo.py │ ├── nav_sol.py │ ├── cfg_dosc.py │ ├── cfg_esrc.py │ ├── aid_hui.py │ ├── mon_hw.py │ ├── rxm_svsi.py │ ├── nav_sbas.py │ ├── rxm_pmreq.py │ ├── nav_status.py │ ├── nav_relposned.py │ ├── mon_gnss.py │ ├── log_info.py │ ├── aid_ini.py │ ├── rxm_measx.py │ ├── esf_status.py │ ├── cfg_cfg.py │ ├── nav_orb.py │ ├── nav_svinfo.py │ ├── cfg_nav5.py │ ├── hnr_pvt.py │ ├── nav_sat.py │ ├── mon_smgr.py │ ├── tim_tos.py │ ├── cfg_smgr.py │ ├── cfg_tp5.py │ ├── rxm_rawx.py │ ├── mga_glo.py │ ├── log_batch.py │ ├── mga_qzss.py │ ├── nav_pvt.py │ ├── rxm_imes.py │ ├── cfg_prt.py │ ├── cfg_nmea.py │ ├── cfg_pm2.py │ ├── cfg_sbas.py │ ├── mga_gal.py │ ├── mga_bds.py │ ├── mga_gps.py │ ├── mga_ini.py │ └── cfg_navx5.py ├── parser.py ├── __init__.py ├── utils.py ├── message_id.py ├── rawmessage.py ├── message_class.py ├── message.py ├── checksum.py ├── reader.py ├── statistics.py └── payload.py ├── setup.py ├── README.md ├── .travis.yml ├── .gitignore └── scripts └── ubxstats /test/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /docs/requirements.txt: -------------------------------------------------------------------------------- 1 | sphinx -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | bitarray -------------------------------------------------------------------------------- /docs/source/_static/.gitignore: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /docs/source/_templates/.gitignore: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /ubx/printing/__init__.py: -------------------------------------------------------------------------------- 1 | from .rst import RST 2 | -------------------------------------------------------------------------------- /ubx/syncchars.py: -------------------------------------------------------------------------------- 1 | """Module defining the UBX syncchar bytes""" 2 | 3 | CHAR1 = b"\xb5" 4 | CHAR2 = b"\x62" 5 | -------------------------------------------------------------------------------- /ubx/descriptions/log_erase.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | description = MessageDescription( 8 | message_class=LOG, 9 | message_id=MessageId("ERASE", b"\x03"), 10 | payload_description=Options( 11 | Empty 12 | ) 13 | ) 14 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_resetodo.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | description = MessageDescription( 8 | message_class=NAV, 9 | message_id=MessageId("RESETODO", b"\x10"), 10 | payload_description=Options( 11 | Empty 12 | ) 13 | ) 14 | -------------------------------------------------------------------------------- /ubx/descriptions/__init__.py: -------------------------------------------------------------------------------- 1 | import os 2 | import importlib 3 | 4 | default = [] 5 | 6 | for name in os.listdir(os.path.dirname(__file__)): 7 | if name.startswith("_") or not name.endswith(".py"): 8 | continue 9 | name = name[:-3] 10 | importlib.import_module("." + name, "ubx.descriptions") 11 | default.append(globals()[name].description) 12 | -------------------------------------------------------------------------------- /ubx/descriptions/ack_ack.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("clsID", U1), 9 | ("msgID", U1) 10 | ) 11 | 12 | description = MessageDescription( 13 | message_class=ACK, 14 | message_id=MessageId("ACK", b"\x01"), 15 | payload_description=payload_description0 16 | ) 17 | -------------------------------------------------------------------------------- /ubx/descriptions/ack_nack.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("clsID", U1), 9 | ("msgID", U1) 10 | ) 11 | 12 | description = MessageDescription( 13 | message_class=ACK, 14 | message_id=MessageId("NACK", b"\x00"), 15 | payload_description=payload_description0 16 | ) 17 | -------------------------------------------------------------------------------- /docs/source/index.rst: -------------------------------------------------------------------------------- 1 | Python-UBX 2 | ========== 3 | 4 | A python library implementing the binary u-blox UBX protocol. 5 | 6 | .. image:: images/schematic.svg 7 | 8 | .. toctree:: 9 | :maxdepth: 2 10 | :caption: Contents: 11 | 12 | generated/message_descriptions/message_descriptions 13 | 14 | 15 | Indices and tables 16 | ================== 17 | 18 | * :ref:`genindex` 19 | * :ref:`modindex` 20 | * :ref:`search` 21 | -------------------------------------------------------------------------------- /ubx/descriptions/inf_test.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("str", Chars(None)), 9 | ) 10 | 11 | description = MessageDescription( 12 | message_class=INF, 13 | message_id=MessageId("TEST", b"\x03"), 14 | payload_description=Options( 15 | payload_description0, 16 | ) 17 | ) 18 | -------------------------------------------------------------------------------- /ubx/descriptions/inf_debug.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("str", Chars(None)), 9 | ) 10 | 11 | description = MessageDescription( 12 | message_class=INF, 13 | message_id=MessageId("DEBUG", b"\x04"), 14 | payload_description=Options( 15 | payload_description0, 16 | ) 17 | ) 18 | -------------------------------------------------------------------------------- /ubx/descriptions/inf_error.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("str", Chars(None)), 9 | ) 10 | 11 | description = MessageDescription( 12 | message_class=INF, 13 | message_id=MessageId("ERROR", b"\x00"), 14 | payload_description=Options( 15 | payload_description0, 16 | ) 17 | ) 18 | -------------------------------------------------------------------------------- /ubx/descriptions/inf_notice.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("str", Chars(None)), 9 | ) 10 | 11 | description = MessageDescription( 12 | message_class=INF, 13 | message_id=MessageId("NOTICE", b"\x02"), 14 | payload_description=Options( 15 | payload_description0, 16 | ) 17 | ) 18 | -------------------------------------------------------------------------------- /ubx/descriptions/inf_warning.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("str", Chars(None)), 9 | ) 10 | 11 | description = MessageDescription( 12 | message_class=INF, 13 | message_id=MessageId("WARNING", b"\x01"), 14 | payload_description=Options( 15 | payload_description0, 16 | ) 17 | ) 18 | -------------------------------------------------------------------------------- /ubx/descriptions/log_string.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = Fields( 8 | ("bytes", MatchedLoop(U1)) 9 | ) 10 | 11 | description = MessageDescription( 12 | message_class=LOG, 13 | message_id=MessageId("STRING", b"\x04"), 14 | payload_description=Options( 15 | payload_description 16 | ) 17 | ) 18 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_eoe.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("iTOW", U4), 9 | ) 10 | 11 | description = MessageDescription( 12 | message_class=NAV, 13 | message_id=MessageId("EOE", b"\x61"), 14 | payload_description=Options( 15 | Empty, 16 | payload_description0, 17 | ) 18 | ) 19 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_rxm.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("reserved1", U1), 9 | ("lpMode", U1) 10 | ) 11 | 12 | description = MessageDescription( 13 | message_class=CFG, 14 | message_id=MessageId("RXM", b"\x11"), 15 | payload_description=Options( 16 | Empty, 17 | payload_description0, 18 | ) 19 | ) 20 | -------------------------------------------------------------------------------- /ubx/descriptions/tim_dosc.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = Fields( 8 | ("version", U1), 9 | ("reserved1", 3*U1), 10 | ("value", U4) 11 | ) 12 | 13 | description = MessageDescription( 14 | message_class=TIM, 15 | message_id=MessageId("DOSC", b"\x11"), 16 | payload_description=Options( 17 | payload_description 18 | ) 19 | ) 20 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_dgnss.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("dgnssMode", U1), 9 | ("reserved1", 3*U1), 10 | ) 11 | 12 | description = MessageDescription( 13 | message_class=CFG, 14 | message_id=MessageId("DGNSS", b"\x70"), 15 | payload_description=Options( 16 | Empty, 17 | payload_description0, 18 | ) 19 | ) 20 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_hnr.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("highNavRate", U1), 9 | ("reserved1", 3*U1), 10 | ) 11 | 12 | description = MessageDescription( 13 | message_class=CFG, 14 | message_id=MessageId("HNR", b"\x5c"), 15 | payload_description=Options( 16 | Empty, 17 | payload_description0, 18 | ) 19 | ) 20 | -------------------------------------------------------------------------------- /ubx/descriptions/mga_dbd.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = Fields( 8 | ("reserved1", 12*U1), 9 | ("data", MatchedLoop(U1)) 10 | ) 11 | 12 | description = MessageDescription( 13 | message_class=MGA, 14 | message_id=MessageId("DBD", b"\x80"), 15 | payload_description=Options( 16 | Empty, 17 | payload_description 18 | ) 19 | ) 20 | -------------------------------------------------------------------------------- /ubx/descriptions/sec_uniqid.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = Fields( 8 | ("version", U1), 9 | ("reserved1", 3*U1), 10 | ("uniqueID", 5*U1), 11 | ) 12 | 13 | description = MessageDescription( 14 | message_class=SEC, 15 | message_id=MessageId("UNIQID", b"\x03"), 16 | payload_description=Options( 17 | payload_description 18 | ) 19 | ) 20 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_pwr.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("version", U1), 9 | ("reserved1", 3*U1), 10 | ("state", U4), 11 | ) 12 | 13 | description = MessageDescription( 14 | message_class=CFG, 15 | message_id=MessageId("PWR", b"\x57"), 16 | payload_description=Options( 17 | Empty, 18 | payload_description0, 19 | ) 20 | ) 21 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_rate.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("measRate", U2), 9 | ("navRate", U2), 10 | ("timeRef", U2), 11 | ) 12 | 13 | description = MessageDescription( 14 | message_class=CFG, 15 | message_id=MessageId("RATE", b"\x08"), 16 | payload_description=Options( 17 | Empty, 18 | payload_description0, 19 | ) 20 | ) 21 | -------------------------------------------------------------------------------- /ubx/descriptions/mon_rxbuf.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = Fields( 8 | ("pending", 6*U2), 9 | ("usage", 6*U1), 10 | ("peakUsage", 6*U1) 11 | ) 12 | 13 | description = MessageDescription( 14 | message_class=MON, 15 | message_id=MessageId("RXBUF", b"\x07"), 16 | payload_description=Options( 17 | Empty, 18 | payload_description 19 | ) 20 | ) 21 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_dynseed.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("version", U1), 9 | ("reserved1", 3*U1), 10 | ("seedHi", U4), 11 | ("seedLo", U4), 12 | ) 13 | 14 | description = MessageDescription( 15 | message_class=CFG, 16 | message_id=MessageId("DYNSEED", b"\x85"), 17 | payload_description=Options( 18 | payload_description0, 19 | ) 20 | ) 21 | -------------------------------------------------------------------------------- /ubx/descriptions/log_retrieve.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = Fields( 8 | ("startNumber", U4), 9 | ("entryCount", U4), 10 | ("version", U1), 11 | ("reserved1", 3*U1) 12 | ) 13 | 14 | description = MessageDescription( 15 | message_class=LOG, 16 | message_id=MessageId("RETRIEVE", b"\x09"), 17 | payload_description=Options( 18 | payload_description 19 | ) 20 | ) 21 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | from setuptools import setup 5 | 6 | 7 | setup(name='python-ubx', 8 | version='0.1', 9 | description='A python library implementing the binary u-blox UBX protocol.', 10 | author='Sebastian Krämer', 11 | author_email='basti.kr@gmail.com', 12 | url='https://github.com/bastikr/python-ubx', 13 | packages=['ubx', 'ubx.descriptions'], 14 | scripts=['scripts/ubxstats'], 15 | install_requires=["bitarray"] 16 | ) 17 | -------------------------------------------------------------------------------- /ubx/descriptions/mon_rxr.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(1, entries=[ 8 | BitfieldEntry("awake", 0) 9 | ]) 10 | 11 | payload_description = Fields( 12 | ("flags", flags), 13 | ) 14 | 15 | description = MessageDescription( 16 | message_class=MON, 17 | message_id=MessageId("RXR", b"\x21"), 18 | payload_description=Options( 19 | Empty, 20 | payload_description 21 | ) 22 | ) 23 | -------------------------------------------------------------------------------- /ubx/descriptions/mga_ack.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = Fields( 8 | ("type", U1), 9 | ("version", U1), 10 | ("infoCode", U1), 11 | ("msgId", U1), 12 | ("msgPayloadStart", 4*U1) 13 | ) 14 | 15 | description = MessageDescription( 16 | message_class=MGA, 17 | message_id=MessageId("ACK", b"\x60"), 18 | payload_description=Options( 19 | payload_description 20 | ) 21 | ) 22 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_clock.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("iTOW", U4), 9 | ("clkB", I4), 10 | ("clkD", I4), 11 | ("tAcc", U4), 12 | ("fAcc", U4) 13 | ) 14 | 15 | description = MessageDescription( 16 | message_class=NAV, 17 | message_id=MessageId("CLOCK", b"\x22"), 18 | payload_description=Options( 19 | Empty, 20 | payload_description0, 21 | ) 22 | ) 23 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_posecef.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("iTOW", U4), 9 | ("ecefX", I4), 10 | ("ecefY", I4), 11 | ("ecefZ", I4), 12 | ("pAcc", U4) 13 | ) 14 | 15 | description = MessageDescription( 16 | message_class=NAV, 17 | message_id=MessageId("POSECEF", b"\x01"), 18 | payload_description=Options( 19 | Empty, 20 | payload_description0, 21 | ) 22 | ) 23 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_velecef.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("iTOW", U4), 9 | ("ecefVX", I4), 10 | ("ecefVY", I4), 11 | ("ecefVZ", I4), 12 | ("sAcc", U4) 13 | ) 14 | 15 | description = MessageDescription( 16 | message_class=NAV, 17 | message_id=MessageId("VELECEF", b"\x11"), 18 | payload_description=Options( 19 | Empty, 20 | payload_description0, 21 | ) 22 | ) 23 | -------------------------------------------------------------------------------- /ubx/descriptions/sec_sign.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = Fields( 8 | ("version", U1), 9 | ("reserved1", 3*U1), 10 | ("classID", U1), 11 | ("messageID", U1), 12 | ("checksum", U2), 13 | ("hash", 32*U1) 14 | ) 15 | 16 | description = MessageDescription( 17 | message_class=SEC, 18 | message_id=MessageId("SIGN", b"\x01"), 19 | payload_description=Options( 20 | payload_description 21 | ) 22 | ) 23 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_pms.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("version", U1), 9 | ("powerSetupValue", U1), 10 | ("period", U2), 11 | ("onTime", U2), 12 | ("reserved1", 2*U1) 13 | ) 14 | 15 | 16 | description = MessageDescription( 17 | message_class=CFG, 18 | message_id=MessageId("PMS", b"\x86"), 19 | payload_description=Options( 20 | Empty, 21 | payload_description0, 22 | ) 23 | ) 24 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_odo.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("version", U1), 9 | ("reserved1", 3*U1), 10 | ("iTOW", U4), 11 | ("distance", U4), 12 | ("totalDistance", U4), 13 | ("distanceStd", U4) 14 | ) 15 | 16 | description = MessageDescription( 17 | message_class=NAV, 18 | message_id=MessageId("ODO", b"\x09"), 19 | payload_description=Options( 20 | Empty, 21 | payload_description0, 22 | ) 23 | ) 24 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_posllh.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("iTOW", U4), 9 | ("lon", I4), 10 | ("lat", I4), 11 | ("height", I4), 12 | ("hMSL", I4), 13 | ("hAcc", U4), 14 | ("vAcc", U4) 15 | ) 16 | 17 | description = MessageDescription( 18 | message_class=NAV, 19 | message_id=MessageId("POSLLH", b"\x02"), 20 | payload_description=Options( 21 | Empty, 22 | payload_description0, 23 | ) 24 | ) 25 | -------------------------------------------------------------------------------- /ubx/descriptions/log_retrievebatch.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(1, entries=[ 8 | BitfieldEntry("sendMonFirst", 0) 9 | ]) 10 | 11 | payload_description = Fields( 12 | ("version", U1), 13 | ("flags", flags), 14 | ("reserved1", 2*U1) 15 | ) 16 | 17 | description = MessageDescription( 18 | message_class=LOG, 19 | message_id=MessageId("RETRIEVEBATCH", b"\x10"), 20 | payload_description=Options( 21 | payload_description 22 | ) 23 | ) 24 | -------------------------------------------------------------------------------- /ubx/descriptions/mon_batch.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = Fields( 8 | ("version", U1), 9 | ("reserved1", 3*U1), 10 | ("fillLevel", U2), 11 | ("dropsAll", U2), 12 | ("dropsSinceMon", U2), 13 | ("nextMsgCnt", U2) 14 | ) 15 | 16 | description = MessageDescription( 17 | message_class=MON, 18 | message_id=MessageId("BATCH", b"\x32"), 19 | payload_description=Options( 20 | Empty, 21 | payload_description 22 | ) 23 | ) 24 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_rinv.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | flags = Bitfield(1, entries=[ 7 | BitfieldEntry("dump", 0), 8 | BitfieldEntry("binary", 1), 9 | ]) 10 | 11 | payload_description0 = Fields( 12 | ("flags", flags), 13 | ("data", MatchedLoop(U1)) 14 | ) 15 | 16 | description = MessageDescription( 17 | message_class=CFG, 18 | message_id=MessageId("RINV", b"\x34"), 19 | payload_description=Options( 20 | Empty, 21 | payload_description0, 22 | ) 23 | ) 24 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_dop.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("iTOW", U4), 9 | ("gDOP", U2), 10 | ("pDOP", U2), 11 | ("tDOP", U2), 12 | ("vDOP", U2), 13 | ("hDOP", U2), 14 | ("nDOP", U2), 15 | ("eDOP", U2), 16 | ) 17 | 18 | description = MessageDescription( 19 | message_class=NAV, 20 | message_id=MessageId("DOP", b"\x04"), 21 | payload_description=Options( 22 | Empty, 23 | payload_description0, 24 | ) 25 | ) 26 | -------------------------------------------------------------------------------- /ubx/descriptions/mon_msgpp.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = Fields( 8 | ("msg1", 8*U2), 9 | ("msg2", 8*U2), 10 | ("msg3", 8*U2), 11 | ("msg4", 8*U2), 12 | ("msg5", 8*U2), 13 | ("msg6", 8*U2), 14 | ("skipped", 6*U4) 15 | 16 | ) 17 | 18 | description = MessageDescription( 19 | message_class=MON, 20 | message_id=MessageId("MSGPP", b"\x06"), 21 | payload_description=Options( 22 | Empty, 23 | payload_description 24 | ) 25 | ) 26 | -------------------------------------------------------------------------------- /ubx/descriptions/aid_aop.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("svid", U1), 9 | ) 10 | 11 | payload_description1 = Fields( 12 | ("gnssId", U1), 13 | ("svId", U1), 14 | ("reserved1", 2*U1), 15 | ("data", 64*U1) 16 | ) 17 | 18 | description = MessageDescription( 19 | message_class=AID, 20 | message_id=MessageId("AOP", b"\x33"), 21 | payload_description=Options( 22 | Empty, 23 | payload_description0, 24 | payload_description1 25 | ) 26 | ) 27 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_aopstatus.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | aopCfg = Bitfield(1, entries=[ 8 | BitfieldEntry("useAOP", 0) 9 | ]) 10 | 11 | payload_description0 = Fields( 12 | ("iTOW", U4), 13 | ("aopCfg", aopCfg), 14 | ("status", U1), 15 | ("reserved1", 10*U1) 16 | ) 17 | 18 | description = MessageDescription( 19 | message_class=NAV, 20 | message_id=MessageId("AOPSTATUS", b"\x60"), 21 | payload_description=Options( 22 | Empty, 23 | payload_description0, 24 | ) 25 | ) 26 | -------------------------------------------------------------------------------- /ubx/descriptions/rxm_rtcm.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(1, entries=[ 8 | BitfieldEntry("crcFailed", 0) 9 | ]) 10 | 11 | payload_description0 = Fields( 12 | ("version", U1), 13 | ("flags", flags), 14 | ("reserved1", 2*U1), 15 | ("refStation", U2), 16 | ("msgType", U2) 17 | ) 18 | 19 | description = MessageDescription( 20 | message_class=RXM, 21 | message_id=MessageId("RTCM", b"\x32"), 22 | payload_description=Options( 23 | payload_description0 24 | ) 25 | ) 26 | -------------------------------------------------------------------------------- /ubx/descriptions/log_create.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | logCfg = Bitfield(1, entries=[ 8 | BitfieldEntry("circular", 0) 9 | ]) 10 | 11 | payload_description = Fields( 12 | ("version", U1), 13 | ("logCfg", logCfg), 14 | ("reserved1", U1), 15 | ("logSize", U1), 16 | ("userDefinedSize", U4) 17 | ) 18 | 19 | description = MessageDescription( 20 | message_class=LOG, 21 | message_id=MessageId("CREATE", b"\x07"), 22 | payload_description=Options( 23 | payload_description 24 | ) 25 | ) 26 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_velned.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("iTOW", U4), 9 | ("velN", I4), 10 | ("velE", I4), 11 | ("velD", I4), 12 | ("speed", U4), 13 | ("gSpeed", U4), 14 | ("heading", I4), 15 | ("sAcc", U4), 16 | ("cAcc", U4) 17 | ) 18 | 19 | description = MessageDescription( 20 | message_class=NAV, 21 | message_id=MessageId("VELNED", b"\x12"), 22 | payload_description=Options( 23 | Empty, 24 | payload_description0, 25 | ) 26 | ) 27 | -------------------------------------------------------------------------------- /ubx/descriptions/tim_svin.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = Fields( 8 | ("dur", U4), 9 | ("meanX", I4), 10 | ("meanY", I4), 11 | ("meanZ", I4), 12 | ("meanV", I4), 13 | ("obs", U4), 14 | ("valid", U1), 15 | ("active", U1), 16 | ("reserved1", 2*U1) 17 | ) 18 | 19 | description = MessageDescription( 20 | message_class=TIM, 21 | message_id=MessageId("SVIN", b"\x04"), 22 | payload_description=Options( 23 | Empty, 24 | payload_description 25 | ) 26 | ) 27 | -------------------------------------------------------------------------------- /ubx/descriptions/mga_ano.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = Fields( 8 | ("type", U1), 9 | ("version", U1), 10 | ("svId", U1), 11 | ("gnssId", U1), 12 | ("year", U1), 13 | ("month", U1), 14 | ("day", U1), 15 | ("reserved1", U1), 16 | ("data", 64*U1), 17 | ("reserved2", 4*U1) 18 | ) 19 | 20 | description = MessageDescription( 21 | message_class=MGA, 22 | message_id=MessageId("ANO", b"\x20"), 23 | payload_description=Options( 24 | payload_description 25 | ) 26 | ) 27 | -------------------------------------------------------------------------------- /ubx/descriptions/tim_hoc.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(1, entries=[ 8 | BitfieldEntry("raw", 0), 9 | BitfieldEntry("difference", 1) 10 | ]) 11 | 12 | payload_description = Fields( 13 | ("version", U1), 14 | ("oscId", U1), 15 | ("flags", flags), 16 | ("reserved1", U1), 17 | ("value", I4) 18 | ) 19 | 20 | description = MessageDescription( 21 | message_class=TIM, 22 | message_id=MessageId("HOC", b"\x17"), 23 | payload_description=Options( 24 | payload_description 25 | ) 26 | ) 27 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_att.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("iTOW", U4), 9 | ("version", U1), 10 | ("reserved1", 3*U1), 11 | ("roll", I4), 12 | ("pitch", I4), 13 | ("heading", I4), 14 | ("accRoll", U4), 15 | ("accPitch", U4), 16 | ("accHeading", U4), 17 | ) 18 | 19 | description = MessageDescription( 20 | message_class=NAV, 21 | message_id=MessageId("ATT", b"\x05"), 22 | payload_description=Options( 23 | Empty, 24 | payload_description0, 25 | ) 26 | ) 27 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_fixseed.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | ids = Fields( 8 | ("classId", U1), 9 | ("msgId", U1), 10 | ) 11 | 12 | payload_description0 = Fields( 13 | ("version", U1), 14 | ("length", U1), 15 | ("reserved1", 2*U1), 16 | ("seedHi", U4), 17 | ("seedLo", U4), 18 | ("ids", KeyLoop("length", ids)) 19 | ) 20 | 21 | description = MessageDescription( 22 | message_class=CFG, 23 | message_id=MessageId("FIXSEED", b"\x84"), 24 | payload_description=Options( 25 | payload_description0, 26 | ) 27 | ) 28 | -------------------------------------------------------------------------------- /ubx/descriptions/tim_fchg.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = Fields( 8 | ("version", U1), 9 | ("reserved1", 3*U1), 10 | ("iTOW", U4), 11 | ("intDeltaFreq", I4), 12 | ("intDeltaFreqUnc", U4), 13 | ("intRaw", U4), 14 | ("extDeltaFreq", I4), 15 | ("extDeltaFreqUnc", U4), 16 | ("extRaw", U4) 17 | ) 18 | 19 | description = MessageDescription( 20 | message_class=TIM, 21 | message_id=MessageId("FCHG", b"\x16"), 22 | payload_description=Options( 23 | Empty, 24 | payload_description 25 | ) 26 | ) 27 | -------------------------------------------------------------------------------- /ubx/descriptions/mon_hw2.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = Fields( 8 | ("ofsI", I1), 9 | ("magI", U1), 10 | ("ofsQ", I1), 11 | ("magQ", U1), 12 | ("cfgSource", U1), 13 | ("reserved1", 3*U1), 14 | ("lowLevCfg", U4), 15 | ("reserved2", 8*U1), 16 | ("postStatus", U4), 17 | ("reserved3", 4*U1) 18 | ) 19 | 20 | description = MessageDescription( 21 | message_class=MON, 22 | message_id=MessageId("HW2", b"\x0b"), 23 | payload_description=Options( 24 | Empty, 25 | payload_description 26 | ) 27 | ) 28 | -------------------------------------------------------------------------------- /ubx/descriptions/tim_vrfy.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(1, entries=[ 8 | BitfieldEntry("src", slice(0, 3)), 9 | ]) 10 | 11 | payload_description = Fields( 12 | ("itow", I4), 13 | ("frac", I4), 14 | ("deltaMs", I4), 15 | ("deltaNs", I4), 16 | ("wno", U2), 17 | ("flags", flags), 18 | ("reserved1", U1) 19 | ) 20 | 21 | description = MessageDescription( 22 | message_class=TIM, 23 | message_id=MessageId("VRFY", b"\x06"), 24 | payload_description=Options( 25 | Empty, 26 | payload_description 27 | ) 28 | ) 29 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_geofence.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | fence = Fields( 8 | ("state", U1), 9 | ("reserved1", U1) 10 | ) 11 | 12 | payload_description0 = Fields( 13 | ("iTOW", U4), 14 | ("version", U1), 15 | ("status", U1), 16 | ("numFences", U1), 17 | ("combState", U1), 18 | ("fences", KeyLoop("numFences", fence)) 19 | ) 20 | 21 | description = MessageDescription( 22 | message_class=NAV, 23 | message_id=MessageId("GEOFENCE", b"\x39"), 24 | payload_description=Options( 25 | Empty, 26 | payload_description0, 27 | ) 28 | ) 29 | -------------------------------------------------------------------------------- /ubx/descriptions/mon_ver.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | errors = Bitfield(1, entries=[ 8 | BitfieldEntry("limit", slice(0, 6)), 9 | BitfieldEntry("mem", 6), 10 | BitfieldEntry("alloc", 7) 11 | ]) 12 | 13 | payload_description = Fields( 14 | ("swVersion", Chars(30)), 15 | ("hwVersion", Chars(10)), 16 | ("extension", MatchedLoop(Chars(30))) 17 | ) 18 | 19 | description = MessageDescription( 20 | message_class=MON, 21 | message_id=MessageId("VER", b"\x04"), 22 | payload_description=Options( 23 | Empty, 24 | payload_description 25 | ) 26 | ) 27 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_hpposecef.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("version", U1), 9 | ("reserved1", 3*U1), 10 | ("iTOW", U4), 11 | ("ecefX", I4), 12 | ("ecefY", I4), 13 | ("ecefZ", I4), 14 | ("ecefXHp", I1), 15 | ("ecefYHp", I1), 16 | ("ecefZHp", I1), 17 | ("reserved2", U1), 18 | ("pAcc", U4) 19 | ) 20 | 21 | description = MessageDescription( 22 | message_class=NAV, 23 | message_id=MessageId("HPPOSECEF", b"\x13"), 24 | payload_description=Options( 25 | Empty, 26 | payload_description0, 27 | ) 28 | ) 29 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_timeglo.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | valid = Bitfield(1, entries=[ 8 | BitfieldEntry("todValid", 0), 9 | BitfieldEntry("dateValid", 1), 10 | ]) 11 | 12 | payload_description0 = Fields( 13 | ("iTOW", U4), 14 | ("TOD", U4), 15 | ("fTOD", I4), 16 | ("Nt", U2), 17 | ("N4", U1), 18 | ("valid", valid), 19 | ("tAcc", U4) 20 | ) 21 | 22 | description = MessageDescription( 23 | message_class=NAV, 24 | message_id=MessageId("TIMEGLO", b"\x23"), 25 | payload_description=Options( 26 | Empty, 27 | payload_description0, 28 | ) 29 | ) 30 | -------------------------------------------------------------------------------- /ubx/descriptions/aid_alm.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("svid", U1) 9 | ) 10 | 11 | payload_description1 = Fields( 12 | ("svid", U4), 13 | ("week", U4), 14 | ) 15 | 16 | payload_description2 = Fields( 17 | ("svid", U4), 18 | ("week", U4), 19 | ("dwrd", 8*U4) 20 | ) 21 | 22 | description = MessageDescription( 23 | message_class=AID, 24 | message_id=MessageId("ALM", b"\x30"), 25 | payload_description=Options( 26 | Empty, 27 | payload_description0, 28 | payload_description1, 29 | payload_description2, 30 | ) 31 | ) 32 | -------------------------------------------------------------------------------- /ubx/descriptions/mon_io.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = MatchedLoop( 8 | Fields( 9 | ("rxBytes", U4), 10 | ("txBytes", U4), 11 | ("parityErrs", U2), 12 | ("framingErrs", U2), 13 | ("overrunErrs", U2), 14 | ("breakCond", U2), 15 | ("rxBusy", U1), 16 | ("txBusy", U1), 17 | ("reserved1", 2*U1) 18 | ) 19 | ) 20 | 21 | description = MessageDescription( 22 | message_class=MON, 23 | message_id=MessageId("IO", b"\x02"), 24 | payload_description=Options( 25 | Empty, 26 | payload_description 27 | ) 28 | ) 29 | -------------------------------------------------------------------------------- /ubx/descriptions/esf_raw.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | data = Bitfield(4, entries=[ 8 | BitfieldEntry("dataField", slice(0, 24)), 9 | BitfieldEntry("dataType", slice(24, 32)) 10 | ]) 11 | 12 | measurement = Fields( 13 | ("data", data), 14 | ("sTtag", U4) 15 | ) 16 | 17 | payload_description0 = Fields( 18 | ("reserved1", 4*U1), 19 | ("measurements", MatchedLoop(measurement)) 20 | ) 21 | 22 | description = MessageDescription( 23 | message_class=ESF, 24 | message_id=MessageId("RAW", b"\x03"), 25 | payload_description=Options( 26 | Empty, 27 | payload_description0, 28 | ) 29 | ) 30 | -------------------------------------------------------------------------------- /ubx/descriptions/log_retrieveposextra.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = Fields( 8 | ("entryIndex", U4), 9 | ("version", U1), 10 | ("reserved1", U1), 11 | ("year", U2), 12 | ("month", U1), 13 | ("day", U1), 14 | ("hour", U1), 15 | ("minute", U1), 16 | ("second", U1), 17 | ("reserved2", 3*U1), 18 | ("distance", U4), 19 | ("reserved3", 12*U1) 20 | ) 21 | 22 | description = MessageDescription( 23 | message_class=LOG, 24 | message_id=MessageId("RETRIEVEPOSEXTRA", b"\x0f"), 25 | payload_description=Options( 26 | payload_description 27 | ) 28 | ) 29 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_timegps.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | valid = Bitfield(1, entries=[ 8 | BitfieldEntry("towValid", 0), 9 | BitfieldEntry("weekValid", 1), 10 | BitfieldEntry("leapSValid", 2), 11 | ]) 12 | 13 | payload_description0 = Fields( 14 | ("iTOW", U4), 15 | ("fTOW", I4), 16 | ("week", I2), 17 | ("leapS", I1), 18 | ("valid", valid), 19 | ("tAcc", U4) 20 | ) 21 | 22 | description = MessageDescription( 23 | message_class=NAV, 24 | message_id=MessageId("TIMEGPS", b"\x20"), 25 | payload_description=Options( 26 | Empty, 27 | payload_description0, 28 | ) 29 | ) 30 | -------------------------------------------------------------------------------- /ubx/descriptions/rxm_sfrbx.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | words_fields = Fields( 8 | ("dwrd", U4) 9 | ) 10 | 11 | payload_description = Fields( 12 | ("gnssId", U1), 13 | ("svId", U1), 14 | ("reserved1", U1), 15 | ("freqId", U1), 16 | ("numWords", U1), 17 | ("chn", U1), 18 | ("version", U1), 19 | ("reserved2", U1), 20 | ("meas", KeyLoop("numWords", words_fields)) 21 | ) 22 | 23 | description = MessageDescription( 24 | message_class=RXM, 25 | message_id=MessageId("SFRBX", b"\x13"), 26 | payload_description=Options( 27 | Empty, 28 | payload_description 29 | ) 30 | ) 31 | -------------------------------------------------------------------------------- /ubx/descriptions/log_retrievestring.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = Fields( 8 | ("entryIndex", U4), 9 | ("version", U1), 10 | ("reserved1", U1), 11 | ("year", U2), 12 | ("month", U1), 13 | ("day", U1), 14 | ("hour", U1), 15 | ("minute", U1), 16 | ("second", U1), 17 | ("reserved2", U1), 18 | ("byteCount", U2), 19 | ("bytes", KeyLoop("byteCount", U1)) 20 | ) 21 | 22 | description = MessageDescription( 23 | message_class=LOG, 24 | message_id=MessageId("RETRIEVESTRING", b"\x0d"), 25 | payload_description=Options( 26 | payload_description 27 | ) 28 | ) 29 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_hpposllh.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("version", U1), 9 | ("reserved1", 3*U1), 10 | ("iTOW", U4), 11 | ("lon", I4), 12 | ("lat", I4), 13 | ("height", I4), 14 | ("hMSL", I4), 15 | ("lonHp", I1), 16 | ("latHp", I1), 17 | ("heightHp", I1), 18 | ("hMSLHp", I1), 19 | ("hAcc", U4), 20 | ("vAcc", U4) 21 | ) 22 | 23 | description = MessageDescription( 24 | message_class=NAV, 25 | message_id=MessageId("HPPOSLLH", b"\x14"), 26 | payload_description=Options( 27 | Empty, 28 | payload_description0, 29 | ) 30 | ) 31 | -------------------------------------------------------------------------------- /test/test_rawmessage.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | 3 | import ubx 4 | 5 | 6 | class TestRawMessage(unittest.TestCase): 7 | def test_length(self): 8 | msg_class = b"\x01" 9 | msg_id = b"\x02" 10 | msg = ubx.RawMessage(msg_class, msg_id, b"") 11 | self.assertEqual(len(msg), 0) 12 | msg = ubx.RawMessage(msg_class, msg_id, b"\x02\xf1") 13 | self.assertEqual(len(msg), 2) 14 | 15 | def test_lengthbytes(self): 16 | msg_class = b"\x01" 17 | msg_id = b"\x02" 18 | msg = ubx.RawMessage(msg_class, msg_id, b"") 19 | self.assertEqual(msg.lengthbytes, b"\x00\x00") 20 | msg = ubx.RawMessage(msg_class, msg_id, b"\x02\xf1") 21 | self.assertEqual(msg.lengthbytes, b"\x02\x00") 22 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_timedbs.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | valid = Bitfield(1, entries=[ 8 | BitfieldEntry("sowValid", 0), 9 | BitfieldEntry("weekValid", 1), 10 | BitfieldEntry("leapSValid", 2), 11 | ]) 12 | 13 | payload_description0 = Fields( 14 | ("iTOW", U4), 15 | ("SOW", U4), 16 | ("fSOW", I4), 17 | ("week", I2), 18 | ("leapS", I1), 19 | ("valid", valid), 20 | ("tAcc", U4) 21 | ) 22 | 23 | description = MessageDescription( 24 | message_class=NAV, 25 | message_id=MessageId("TIMEDBS", b"\x24"), 26 | payload_description=Options( 27 | Empty, 28 | payload_description0, 29 | ) 30 | ) 31 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_msg.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("msgClass", U1), 9 | ("msgID", U1) 10 | ) 11 | 12 | payload_description1 = Fields( 13 | ("msgClass", U1), 14 | ("msgID", U1), 15 | ("rate", 6*U1) 16 | ) 17 | 18 | payload_description2 = Fields( 19 | ("msgClass", U1), 20 | ("msgID", U1), 21 | ("rate", U1) 22 | ) 23 | 24 | description = MessageDescription( 25 | message_class=CFG, 26 | message_id=MessageId("MSG", b"\x01"), 27 | payload_description=Options( 28 | payload_description0, 29 | payload_description1, 30 | payload_description2 31 | ) 32 | ) 33 | -------------------------------------------------------------------------------- /ubx/descriptions/aid_eph.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("svid", U1) 9 | ) 10 | 11 | payload_description1 = Fields( 12 | ("svid", U4), 13 | ("how", U4), 14 | ) 15 | 16 | payload_description2 = Fields( 17 | ("svid", U4), 18 | ("how", U4), 19 | ("sf1d", 8*U4), 20 | ("sf2d", 8*U4), 21 | ("sf3d", 8*U4) 22 | ) 23 | 24 | description = MessageDescription( 25 | message_class=AID, 26 | message_id=MessageId("EPH", b"\x31"), 27 | payload_description=Options( 28 | Empty, 29 | payload_description0, 30 | payload_description1, 31 | payload_description2, 32 | ) 33 | ) 34 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_timegal.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | valid = Bitfield(1, entries=[ 8 | BitfieldEntry("galTowValid", 0), 9 | BitfieldEntry("galWnoValid", 1), 10 | BitfieldEntry("leapSValid", 2), 11 | ]) 12 | 13 | payload_description0 = Fields( 14 | ("iTOW", U4), 15 | ("galTow", U4), 16 | ("fGalTow", I4), 17 | ("galWno", I2), 18 | ("leapS", I1), 19 | ("valid", valid), 20 | ("tAcc", U4) 21 | ) 22 | 23 | description = MessageDescription( 24 | message_class=NAV, 25 | message_id=MessageId("TIMEGAL", b"\x25"), 26 | payload_description=Options( 27 | Empty, 28 | payload_description0, 29 | ) 30 | ) 31 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_txslot.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | enable = Bitfield(1, entries=[ 8 | BitfieldEntry("DDC", 0), 9 | BitfieldEntry("UART1", 1), 10 | BitfieldEntry("UART2", 2), 11 | BitfieldEntry("USB", 3), 12 | BitfieldEntry("SPI", 4) 13 | ]) 14 | 15 | payload_description0 = Fields( 16 | ("version", U1), 17 | ("enable", enable), 18 | ("refTp", U1), 19 | ("reserved1", U1), 20 | ("end", 4*U4) 21 | ) 22 | 23 | description = MessageDescription( 24 | message_class=CFG, 25 | message_id=MessageId("TXSLOT", b"\x53"), 26 | payload_description=Options( 27 | Empty, 28 | payload_description0, 29 | ) 30 | ) 31 | -------------------------------------------------------------------------------- /docs/Makefile: -------------------------------------------------------------------------------- 1 | # Minimal makefile for Sphinx documentation 2 | # 3 | 4 | # You can set these variables from the command line. 5 | SPHINXOPTS = 6 | SPHINXBUILD = sphinx-build 7 | SPHINXPROJ = Python-UBX 8 | SOURCEDIR = source 9 | BUILDDIR = build 10 | SCRIPTSDIR = scripts 11 | 12 | # Put it first so that "make" without argument is like "make help". 13 | help: 14 | @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) 15 | 16 | .PHONY: help Makefile 17 | 18 | # Catch-all target: route all unknown targets to Sphinx using the new 19 | # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). 20 | %: Makefile 21 | python $(SCRIPTSDIR)/generate_messages.py 22 | @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) 23 | -------------------------------------------------------------------------------- /ubx/descriptions/mon_txbuf.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | errors = Bitfield(1, entries=[ 8 | BitfieldEntry("limit", slice(0, 6)), 9 | BitfieldEntry("mem", 6), 10 | BitfieldEntry("alloc", 7) 11 | ]) 12 | 13 | payload_description = Fields( 14 | ("pending", 6*U2), 15 | ("usage", 6*U1), 16 | ("peakUsage", 6*U1), 17 | ("tUsage", U1), 18 | ("tPeakusage", U1), 19 | ("errors", errors), 20 | ("reserved1", U1) 21 | ) 22 | 23 | description = MessageDescription( 24 | message_class=MON, 25 | message_id=MessageId("TXBUF", b"\x08"), 26 | payload_description=Options( 27 | Empty, 28 | payload_description 29 | ) 30 | ) 31 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_geofence.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | fences = Fields( 8 | ("lat", I4), 9 | ("lon", I4), 10 | ("radius", U4) 11 | ) 12 | 13 | payload_description0 = Fields( 14 | ("version", U1), 15 | ("numFences", U1), 16 | ("confLvl", U1), 17 | ("reserved1", U1), 18 | ("pioEnabled", U1), 19 | ("pinPolarity", U1), 20 | ("pin", U1), 21 | ("reserved2", U1), 22 | ("fences", KeyLoop("numFences", fences)) 23 | ) 24 | 25 | description = MessageDescription( 26 | message_class=CFG, 27 | message_id=MessageId("GEOFENCE", b"\x69"), 28 | payload_description=Options( 29 | Empty, 30 | payload_description0, 31 | ) 32 | ) 33 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_tmode2.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(2, entries=[ 8 | BitfieldEntry("lla", 0), 9 | BitfieldEntry("altInv", 1), 10 | ]) 11 | 12 | payload_description0 = Fields( 13 | ("timeMode", U1), 14 | ("reserved1", U1), 15 | ("flags", flags), 16 | ("ecefXOrLat", I4), 17 | ("ecefYOrLon", I4), 18 | ("ecefZOrAlt", I4), 19 | ("fixedPosAcc", U4), 20 | ("svinMinDur", U4), 21 | ("svinAccLim", U4) 22 | ) 23 | 24 | description = MessageDescription( 25 | message_class=CFG, 26 | message_id=MessageId("TMODE2", b"\x3d"), 27 | payload_description=Options( 28 | Empty, 29 | payload_description0, 30 | ) 31 | ) 32 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_logfilter.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(1, entries=[ 8 | BitfieldEntry("recordEnabled", 0), 9 | BitfieldEntry("psmOncePerWakupEnabled", 1), 10 | BitfieldEntry("applyAllFilterSettings", 2), 11 | ]) 12 | 13 | payload_description0 = Fields( 14 | ("version", U1), 15 | ("flags", flags), 16 | ("minInterval", U2), 17 | ("timeThreshold", U2), 18 | ("speedThreshold", U2), 19 | ("positionThreshold", U4), 20 | ) 21 | 22 | description = MessageDescription( 23 | message_class=CFG, 24 | message_id=MessageId("LOGFILTER", b"\x47"), 25 | payload_description=Options( 26 | Empty, 27 | payload_description0 28 | ) 29 | ) 30 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Python-UBX 2 | 3 | [![Latest Docs][docs-latest-img]][docs-latest-url] 4 | [![Travis build status][travis-img]][travis-url] 5 | [![Test coverage status on codecov][codecov-img]][codecov-url] 6 | 7 | A python library implementing the binary u-blox UBX protocol. 8 | 9 | 10 | 11 | [travis-url]: https://travis-ci.org/bastikr/python-ubx 12 | [travis-img]: https://travis-ci.org/bastikr/python-ubx.svg?branch=master 13 | [docs-latest-img]:https://img.shields.io/badge/docs-latest-blue.svg 14 | [docs-latest-url]:https://bastikr.github.io/python-ubx/ 15 | [codecov-url]: https://codecov.io/gh/bastikr/python-ubx 16 | [codecov-img]: https://codecov.io/gh/bastikr/python-ubx/branch/master/graph/badge.svg 17 | -------------------------------------------------------------------------------- /ubx/parser.py: -------------------------------------------------------------------------------- 1 | from . import payload 2 | 3 | 4 | class Parser: 5 | def __init__(self, *descriptions): 6 | self.descriptions = {} 7 | for d in descriptions: 8 | self.add_description(d) 9 | 10 | def add_description(self, description): 11 | self.descriptions[description.key] = description 12 | 13 | def parse(self, rawmsg): 14 | key = rawmsg.key 15 | if key not in self.descriptions: 16 | raise KeyError("No description for " + str(rawmsg)) 17 | else: 18 | buffer = payload.Buffer(rawmsg.payload, index=0) 19 | msg = self.descriptions[key].parse(buffer) 20 | if buffer.remaining_bytesize != 0: 21 | raise payload.PayloadError("Not all bytes used.", buffer, None) 22 | return msg 23 | -------------------------------------------------------------------------------- /ubx/__init__.py: -------------------------------------------------------------------------------- 1 | from . import syncchars 2 | from . import message_class 3 | from . import message_id 4 | 5 | from .message_class import MessageClass 6 | from .message_id import MessageId 7 | from .checksum import Checksum, ChecksumError 8 | from .rawmessage import RawMessage 9 | from .message import Message 10 | 11 | from .payload import Empty, AtomicVariable,\ 12 | U1, U2, U4, U8,\ 13 | I1, I2, I4, I8,\ 14 | R4, R8,\ 15 | Bitfield, BitfieldEntry,\ 16 | X1, X2, X4, X8,\ 17 | Fields, List, KeyLoop, MatchedLoop, Options,\ 18 | PayloadError 19 | 20 | from . import descriptions 21 | 22 | from .reader import Reader, ReaderException 23 | from .parser import Parser 24 | from .statistics import Statistics 25 | 26 | default_parser = Parser(*descriptions.default) 27 | 28 | from . import printing 29 | -------------------------------------------------------------------------------- /ubx/descriptions/mon_patch.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | patchInfo = Bitfield(4, entries=[ 8 | BitfieldEntry("activated", 0), 9 | BitfieldEntry("location", slice(1, 3)) 10 | ]) 11 | 12 | entry = Fields( 13 | ("patchInfo", patchInfo), 14 | ("comparatorNumber", U4), 15 | ("patchAddress", U4), 16 | ("patchData", U4) 17 | ) 18 | 19 | payload_description = Fields( 20 | ("version", U2), 21 | ("nEntries", U2), 22 | ("entries", KeyLoop("nEntries", entry)) 23 | ) 24 | 25 | description = MessageDescription( 26 | message_class=MON, 27 | message_id=MessageId("PATCH", b"\x27"), 28 | payload_description=Options( 29 | Empty, 30 | payload_description 31 | ) 32 | ) 33 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_svin.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("version", U1), 9 | ("reserved1", 3*U1), 10 | ("iTOW", U4), 11 | ("dur", U4), 12 | ("meanX", I4), 13 | ("meanY", I4), 14 | ("meanZ", I4), 15 | ("meanXHP", I1), 16 | ("meanYHP", I1), 17 | ("meanZHP", I1), 18 | ("reserved2", U1), 19 | ("meanAcc", U4), 20 | ("obs", U4), 21 | ("valid", U1), 22 | ("active", U1), 23 | ("reserved3", 2*U1) 24 | ) 25 | 26 | description = MessageDescription( 27 | message_class=NAV, 28 | message_id=MessageId("SVIN", b"\x3b"), 29 | payload_description=Options( 30 | Empty, 31 | payload_description0, 32 | ) 33 | ) 34 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_batch.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(2, entries=[ 8 | BitfieldEntry("enable", 0), 9 | BitfieldEntry("extraPvt", 2), 10 | BitfieldEntry("extraOdo", 3), 11 | BitfieldEntry("pioEnable", 5), 12 | BitfieldEntry("pioActiveLow", 6) 13 | 14 | ]) 15 | 16 | payload_description0 = Fields( 17 | ("version", U1), 18 | ("flags", flags), 19 | ("bufSize", U2), 20 | ("notifThrs", U2), 21 | ("pioId", U1), 22 | ("reserved1", U1) 23 | ) 24 | 25 | description = MessageDescription( 26 | message_class=CFG, 27 | message_id=MessageId("BATCH", b"\x93"), 28 | payload_description=Options( 29 | Empty, 30 | payload_description0, 31 | ) 32 | ) 33 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_usb.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(2, entries=[ 8 | BitfieldEntry("reEnum", 0), 9 | BitfieldEntry("powerMode", 1), 10 | ]) 11 | 12 | payload_description0 = Fields( 13 | ("vendorID", U2), 14 | ("productID", U2), 15 | ("reserved1", 2*U1), 16 | ("reserved2", 2*U1), 17 | ("powerConsumption", U2), 18 | ("flags", flags), 19 | ("vendorString", Chars(32)), 20 | ("productString", Chars(32)), 21 | ("serialNumber", Chars(32)), 22 | ) 23 | 24 | description = MessageDescription( 25 | message_class=CFG, 26 | message_id=MessageId("USB", b"\x1b"), 27 | payload_description=Options( 28 | Empty, 29 | payload_description0, 30 | ) 31 | ) 32 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: python 2 | 3 | os: 4 | - "linux" 5 | # - "osx" 6 | 7 | python: 8 | - "2.7" 9 | - "3.5" 10 | - "3.6" 11 | 12 | cache: pip 13 | 14 | before_install: 15 | 16 | install: 17 | - pip install travis-sphinx 18 | - pip install codecov 19 | - pip install -r requirements.txt 20 | - git clone https://github.com/bastikr/ubx-testdata.git 21 | - export PYTHONPATH=$PYTHONPATH:`pwd` 22 | - cd docs 23 | - if [[ "$TRAVIS_PYTHON_VERSION" == "3.6" ]]; then 24 | python scripts/generate_messages.py; 25 | fi 26 | - cd .. 27 | 28 | script: 29 | # - python -m unittest discover test 30 | - coverage run --source . setup.py test 31 | - if [[ "$TRAVIS_PYTHON_VERSION" == "3.6" ]]; then 32 | travis-sphinx build; 33 | fi 34 | 35 | after_success: 36 | - travis-sphinx deploy 37 | - codecov 38 | -------------------------------------------------------------------------------- /ubx/descriptions/log_retrievepos.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description = Fields( 8 | ("entryIndex", U4), 9 | ("lon", I4), 10 | ("lat", I4), 11 | ("hMSL", I4), 12 | ("hAcc", U4), 13 | ("gSpeed", U4), 14 | ("heading", U4), 15 | ("version", U1), 16 | ("fixType", U1), 17 | ("year", U2), 18 | ("month", U1), 19 | ("day", U1), 20 | ("hour", U1), 21 | ("minute", U1), 22 | ("second", U1), 23 | ("reserved1", U1), 24 | ("numSV", U1), 25 | ("reserved2", U1) 26 | ) 27 | 28 | description = MessageDescription( 29 | message_class=LOG, 30 | message_id=MessageId("RETRIEVEPOS", b"\x0b"), 31 | payload_description=Options( 32 | payload_description 33 | ) 34 | ) 35 | -------------------------------------------------------------------------------- /ubx/descriptions/log_findtime.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | # Request 7 | payload_description0 = Fields( 8 | ("version", U1), 9 | ("type", U1), 10 | ("reserved1", 2*U1), 11 | ("year", U2), 12 | ("month", U1), 13 | ("day", U1), 14 | ("hour", U1), 15 | ("minute", U1), 16 | ("second", U1), 17 | ("reserved2", U1) 18 | ) 19 | 20 | # Response 21 | payload_description1 = Fields( 22 | ("version", U1), 23 | ("type", U1), 24 | ("reserved1", 2*U1), 25 | ("entryNumber", U4), 26 | ) 27 | 28 | description = MessageDescription( 29 | message_class=LOG, 30 | message_id=MessageId("FINDTIME", b"\x0e"), 31 | payload_description=Options( 32 | payload_description0, 33 | payload_description1 34 | ) 35 | ) 36 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_timeutc.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | valid = Bitfield(1, entries=[ 8 | BitfieldEntry("validTOW", 0), 9 | BitfieldEntry("validWKN", 1), 10 | BitfieldEntry("validUTC", 1), 11 | BitfieldEntry("utcStandard", slice(4, 8)) 12 | ]) 13 | 14 | payload_description0 = Fields( 15 | ("iTOW", U4), 16 | ("tAcc", U4), 17 | ("nano", I4), 18 | ("year", U2), 19 | ("month", U1), 20 | ("day", U1), 21 | ("hour", U1), 22 | ("min", U1), 23 | ("sec", U1), 24 | ("valid", valid), 25 | ) 26 | 27 | description = MessageDescription( 28 | message_class=NAV, 29 | message_id=MessageId("TIMEUTC", b"\x21"), 30 | payload_description=Options( 31 | Empty, 32 | payload_description0, 33 | ) 34 | ) 35 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_rst.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | navBbrMask = Bitfield(1, entries=[ 8 | BitfieldEntry("eph", 0), 9 | BitfieldEntry("alm", 1), 10 | BitfieldEntry("health", 2), 11 | BitfieldEntry("klob", 3), 12 | BitfieldEntry("pos", 4), 13 | BitfieldEntry("clkd", 5), 14 | BitfieldEntry("osc", 6), 15 | BitfieldEntry("utc", 7), 16 | BitfieldEntry("rtc", 8), 17 | BitfieldEntry("aop", 15), 18 | ]) 19 | 20 | payload_description0 = Fields( 21 | ("navBbrMask", navBbrMask), 22 | ("resetMode", U1) 23 | ) 24 | 25 | description = MessageDescription( 26 | message_class=CFG, 27 | message_id=MessageId("RST", b"\x04"), 28 | payload_description=Options( 29 | Empty, 30 | payload_description0, 31 | ) 32 | ) 33 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_inf.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("protocolID", U1), 9 | ) 10 | 11 | infMsgMask = Bitfield(1, entries=[ 12 | BitfieldEntry("ERROR", 0), 13 | BitfieldEntry("WARNING", 1), 14 | BitfieldEntry("NOTICE", 2), 15 | BitfieldEntry("TEST", 3), 16 | BitfieldEntry("DEBUG", 4), 17 | ]) 18 | 19 | payload_description1 = MatchedLoop( 20 | Fields( 21 | ("protocolID", U1), 22 | ("reserved1", 3*U1), 23 | ("infMsgMask", 6*infMsgMask) 24 | ) 25 | ) 26 | 27 | description = MessageDescription( 28 | message_class=CFG, 29 | message_id=MessageId("INF", b"\x02"), 30 | payload_description=Options( 31 | payload_description0, 32 | payload_description1, 33 | ) 34 | ) 35 | -------------------------------------------------------------------------------- /ubx/utils.py: -------------------------------------------------------------------------------- 1 | """Module collecting several non-ubx related functions.""" 2 | 3 | import codecs 4 | 5 | 6 | def byte2hexstring(byte): 7 | """ 8 | Return a string containing the hex representation of a given byte. 9 | """ 10 | if not isinstance(byte, bytes): 11 | raise TypeError("Expected argument \"byte\" to be of type \"bytes\" but it is of type \"{}\"".format(type(byte))) 12 | if len(byte)!=1: 13 | raise ValueError("Expected length of the given bytestring to by equal to 1.") 14 | return codecs.encode(byte, "hex").decode("utf-8") 15 | 16 | 17 | def hexstring2byte(hexstring): 18 | """ 19 | Return a byte corresponding to the given hex string. 20 | """ 21 | if len(hexstring)!=2: 22 | raise ValueError("Expected length of the given hexstring to by equal to 2.") 23 | return codecs.decode(hexstring.encode("utf-8"), "hex") 24 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_gnss.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(4, [ 8 | BitfieldEntry("enable", 0), 9 | BitfieldEntry("sigCfgMask", slice(16, 24)) 10 | ]) 11 | 12 | cfgBlocks = Fields( 13 | ("gnssId", U1), 14 | ("resTrkCh", U1), 15 | ("maxTrkCh", U1), 16 | ("reserved1", U1), 17 | ("flags", flags) 18 | ) 19 | 20 | payload_description0 = Fields( 21 | ("msgVer", U1), 22 | ("numTrkChHw", U1), 23 | ("numTrkChUse", U1), 24 | ("numCfgBlocks", U1), 25 | ("cfgBlocks", KeyLoop("numCfgBlocks", cfgBlocks)) 26 | ) 27 | 28 | description = MessageDescription( 29 | message_class=CFG, 30 | message_id=MessageId("GNSS", b"\x3e"), 31 | payload_description=Options( 32 | Empty, 33 | payload_description0, 34 | ) 35 | ) 36 | -------------------------------------------------------------------------------- /ubx/descriptions/tim_tp.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(1, ( 8 | BitfieldEntry("timeBase", 0), 9 | BitfieldEntry("utc", 1), 10 | BitfieldEntry("raim", slice(2, 4)), 11 | ) 12 | ) 13 | 14 | refInfo = Bitfield(1, ( 15 | BitfieldEntry("timeRefGnss", slice(0, 4)), 16 | BitfieldEntry("utcStandard", slice(4, 8)), 17 | ) 18 | ) 19 | 20 | payload_description = Fields( 21 | ("towMS", U4), 22 | ("towSubMS", U4), 23 | ("qErr", I4), 24 | ("week", U2), 25 | ("flags", flags), 26 | ("refInfo", refInfo) 27 | ) 28 | 29 | description = MessageDescription( 30 | message_class=TIM, 31 | message_id=MessageId("TP", b"\x01"), 32 | payload_description=Options( 33 | Empty, 34 | payload_description 35 | ) 36 | ) 37 | -------------------------------------------------------------------------------- /ubx/descriptions/mga_flash.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description_data = Fields( 8 | ("type", U1), 9 | ("version", U1), 10 | ("sequence", U2), 11 | ("size", U2), 12 | ("data", KeyLoop("size", U1)) 13 | ) 14 | 15 | payload_description_stop = Fields( 16 | ("type", U1), 17 | ("version", U1) 18 | ) 19 | 20 | payload_description_ack = Fields( 21 | ("type", U1), 22 | ("version", U1), 23 | ("ack", U1), 24 | ("reserved1", U1), 25 | ("sequence", U2) 26 | ) 27 | 28 | description = MessageDescription( 29 | message_class=MGA, 30 | message_id=MessageId("FLASH", b"\x21"), 31 | payload_description=Options( 32 | payload_description_stop, 33 | payload_description_ack, 34 | payload_description_data 35 | ) 36 | ) 37 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_timels.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | valid = Bitfield(1, entries=[ 8 | BitfieldEntry("validCurrLs", 0), 9 | BitfieldEntry("validTimeToLsEvent", 1), 10 | ]) 11 | 12 | payload_description0 = Fields( 13 | ("iTOW", U4), 14 | ("version", U1), 15 | ("reserved1", 3*U1), 16 | ("srcOfCurrLs", U1), 17 | ("currLs", I1), 18 | ("srcOfLsChange", U1), 19 | ("lsChange", I1), 20 | ("timeToLsEvent", I4), 21 | ("dateOfLsGpsWn", U2), 22 | ("dateOfLsGpsDn", U2), 23 | ("reserved2", 3*U1), 24 | ("valid", valid), 25 | ) 26 | 27 | description = MessageDescription( 28 | message_class=NAV, 29 | message_id=MessageId("TIMELS", b"\x26"), 30 | payload_description=Options( 31 | Empty, 32 | payload_description0, 33 | ) 34 | ) 35 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_itfm.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | config = Bitfield(4, entries=[ 8 | BitfieldEntry("bbThreshold", slice(0, 4)), 9 | BitfieldEntry("cwThreshold", slice(4, 9)), 10 | BitfieldEntry("algorithmBits", slice(9, 32)), 11 | BitfieldEntry("enable", 31) 12 | ]) 13 | 14 | config2 = Bitfield(4, entries=[ 15 | BitfieldEntry("generalBits", slice(0, 12)), 16 | BitfieldEntry("antSetting", slice(12, 14)), 17 | BitfieldEntry("enable2", 14) 18 | ]) 19 | 20 | payload_description0 = Fields( 21 | ("config", config), 22 | ("config2", config2), 23 | ) 24 | 25 | description = MessageDescription( 26 | message_class=CFG, 27 | message_id=MessageId("ITFM", b"\x39"), 28 | payload_description=Options( 29 | Empty, 30 | payload_description0 31 | ) 32 | ) 33 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_dgps.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(1, entries=[ 8 | BitfieldEntry("channel", slice(0, 4)), 9 | BitfieldEntry("dgpsUsed", 4) 10 | ]) 11 | 12 | ch = Fields( 13 | ("svid", U1), 14 | ("flags", flags), 15 | ("ageC", U2), 16 | ("prc", R4), 17 | ("prrc", R4) 18 | ) 19 | 20 | payload_description0 = Fields( 21 | ("iTOW", U4), 22 | ("age", I4), 23 | ("baseId", I2), 24 | ("baseHealth", I2), 25 | ("numCh", U1), 26 | ("status", U1), 27 | ("reserved1", 2*U1), 28 | ("chs", KeyLoop("numCh", ch)) 29 | ) 30 | 31 | description = MessageDescription( 32 | message_class=NAV, 33 | message_id=MessageId("DGPS", b"\x31"), 34 | payload_description=Options( 35 | Empty, 36 | payload_description0, 37 | ) 38 | ) 39 | -------------------------------------------------------------------------------- /ubx/descriptions/rxm_rlm.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("version", U1), 9 | ("type", U1), 10 | ("svId", U1), 11 | ("reserved1", U1), 12 | ("beacon", 8*U1), 13 | ("message", U1), 14 | ("params", 2*U1), 15 | ("reserved2", U1) 16 | ) 17 | 18 | payload_description1 = Fields( 19 | ("version", U1), 20 | ("type", U1), 21 | ("svId", U1), 22 | ("reserved1", U1), 23 | ("beacon", 8*U1), 24 | ("message", U1), 25 | ("params", 12*U1), 26 | ("reserved2", 3*U1) 27 | ) 28 | 29 | description = MessageDescription( 30 | message_class=RXM, 31 | message_id=MessageId("RLM", b"\x59"), 32 | payload_description=Options( 33 | Empty, 34 | payload_description0, 35 | payload_description1 36 | ) 37 | ) 38 | -------------------------------------------------------------------------------- /test/test_utils.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | import ubx 3 | 4 | 5 | class TestByteHexConversion(unittest.TestCase): 6 | def test_conversion(self): 7 | byte = b"\x03" 8 | hexstring = ubx.utils.byte2hexstring(byte) 9 | self.assertEqual(hexstring, "03") 10 | self.assertEqual(byte, ubx.utils.hexstring2byte(hexstring)) 11 | 12 | def test_exceptions_hexstring2bytestring(self): 13 | with self.assertRaises(TypeError): 14 | ubx.utils.byte2hexstring(u"a") 15 | with self.assertRaises(TypeError): 16 | ubx.utils.byte2hexstring(3) 17 | with self.assertRaises(ValueError): 18 | ubx.utils.byte2hexstring(b"\x04\x03") 19 | 20 | def test_exceptions_bytestring2hexstring(self): 21 | with self.assertRaises(ValueError): 22 | ubx.utils.hexstring2byte("4512") 23 | 24 | 25 | if __name__ == '__main__': 26 | unittest.main() 27 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_ant.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(2, entries=[ 8 | BitfieldEntry("scvs", 0), 9 | BitfieldEntry("scd", 1), 10 | BitfieldEntry("ocd", 2), 11 | BitfieldEntry("pdwnOnSCD", 3), 12 | BitfieldEntry("recovery", 4), 13 | ]) 14 | 15 | pins = Bitfield(2, entries=[ 16 | BitfieldEntry("pinSwitch", slice(0, 5)), 17 | BitfieldEntry("pinSCD", slice(5, 10)), 18 | BitfieldEntry("pinOCD", slice(10, 15)), 19 | BitfieldEntry("reconfig", 15) 20 | ]) 21 | 22 | payload_description0 = Fields( 23 | ("flags", flags), 24 | ("pins", pins), 25 | ) 26 | 27 | description = MessageDescription( 28 | message_class=CFG, 29 | message_id=MessageId("ANT", b"\x13"), 30 | payload_description=Options( 31 | Empty, 32 | payload_description0, 33 | ) 34 | ) 35 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_tmode3.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(2, entries=[ 8 | BitfieldEntry("mode", slice(0, 8)), 9 | BitfieldEntry("lla", 8), 10 | ]) 11 | 12 | payload_description0 = Fields( 13 | ("version", U1), 14 | ("reserved1", U1), 15 | ("flags", flags), 16 | ("ecefXOrLat", I4), 17 | ("ecefYOrLon", I4), 18 | ("ecefZOrAlt", I4), 19 | ("ecefXOrLatHP", I1), 20 | ("ecefYOrLonHP", I1), 21 | ("ecefZOrAltHP", I1), 22 | ("reserved2", U1), 23 | ("fixedPosAcc", U4), 24 | ("svinMinDur", U4), 25 | ("svinAccLimit", U4), 26 | ("reserved3", 8*U1), 27 | ) 28 | 29 | description = MessageDescription( 30 | message_class=CFG, 31 | message_id=MessageId("TMODE3", b"\x71"), 32 | payload_description=Options( 33 | Empty, 34 | payload_description0, 35 | ) 36 | ) 37 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_dat.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("majA", R8), 9 | ("flat", R8), 10 | ("dX", R4), 11 | ("dY", R4), 12 | ("dZ", R4), 13 | ("rotX", R4), 14 | ("rotY", R4), 15 | ("rotZ", R4), 16 | ("scale", R4) 17 | ) 18 | 19 | payload_description1 = Fields( 20 | ("datumNum", U2), 21 | ("datumName", Chars(6)), 22 | ("majA", R8), 23 | ("flat", R8), 24 | ("dX", R4), 25 | ("dY", R4), 26 | ("dZ", R4), 27 | ("rotX", R4), 28 | ("rotY", R4), 29 | ("rotZ", R4), 30 | ("scale", R4) 31 | ) 32 | 33 | description = MessageDescription( 34 | message_class=CFG, 35 | message_id=MessageId("DAT", b"\x06"), 36 | payload_description=Options( 37 | Empty, 38 | payload_description0, 39 | payload_description1, 40 | ) 41 | ) 42 | -------------------------------------------------------------------------------- /ubx/descriptions/tim_vcocal.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description0 = Fields( 8 | ("type", U1) 9 | ) 10 | 11 | payload_description1 = Fields( 12 | ("type", U1), 13 | ("version", U1), 14 | ("oscId", U1), 15 | ("srcId", U1), 16 | ("reserved1", 2*U1), 17 | ("raw0", U2), 18 | ("raw1", U2), 19 | ("maxStepSize", U2) 20 | ) 21 | 22 | payload_description2 = Fields( 23 | ("type", U1), 24 | ("version", U1), 25 | ("oscId", U1), 26 | ("reserved1", 3*U1), 27 | ("gainUncertainty", U2), 28 | ("gainVco", I4) 29 | ) 30 | 31 | description = MessageDescription( 32 | message_class=TIM, 33 | message_id=MessageId("VCOCAL", b"\x15"), 34 | payload_description=Options( 35 | Empty, 36 | payload_description0, 37 | payload_description1, 38 | payload_description2 39 | ) 40 | ) 41 | -------------------------------------------------------------------------------- /ubx/descriptions/tim_tm2.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(1, entries=[ 8 | BitfieldEntry("mode", 0), 9 | BitfieldEntry("run", 1), 10 | BitfieldEntry("newFallingEdge", 2), 11 | BitfieldEntry("timeBase", slice(3, 5)), 12 | BitfieldEntry("utc", 5), 13 | BitfieldEntry("time", 6), 14 | BitfieldEntry("newRisingEdge", 7) 15 | ]) 16 | 17 | payload_description = Fields( 18 | ("ch", U1), 19 | ("flags", flags), 20 | ("count", U2), 21 | ("wnR", U2), 22 | ("wnF", U2), 23 | ("towMsR", U4), 24 | ("towSubMsR", U4), 25 | ("towMsF", U4), 26 | ("towSubMsF", U4), 27 | ("accEst", U4) 28 | ) 29 | 30 | description = MessageDescription( 31 | message_class=TIM, 32 | message_id=MessageId("TM2", b"\x03"), 33 | payload_description=Options( 34 | Empty, 35 | payload_description 36 | ) 37 | ) 38 | -------------------------------------------------------------------------------- /ubx/descriptions/tim_smeas.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(1, entries=[ 8 | BitfieldEntry("freqValid", 0), 9 | BitfieldEntry("phaseValid", 1), 10 | ]) 11 | 12 | meas = Fields( 13 | ("sourceId", U1), 14 | ("flags", flags), 15 | ("phaseOffsetFrac", I1), 16 | ("phaseUncFrac", U1), 17 | ("phaseOffset", I4), 18 | ("phaseUnc", U4), 19 | ("reserved3", 4*U1), 20 | ("freqOffset", I4), 21 | ("freqUnc", U4) 22 | ) 23 | 24 | payload_description = Fields( 25 | ("version", U1), 26 | ("numMeas", U1), 27 | ("reserved1", 2*U1), 28 | ("iTOW", U4), 29 | ("reserved2", 4*U1), 30 | ("meass", KeyLoop("numMeas", meas)) 31 | ) 32 | 33 | description = MessageDescription( 34 | message_class=TIM, 35 | message_id=MessageId("SMEAS", b"\x13"), 36 | payload_description=Options( 37 | Empty, 38 | payload_description 39 | ) 40 | ) 41 | -------------------------------------------------------------------------------- /ubx/descriptions/esf_ins.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | bitfield0 = Bitfield(4, entries=[ 8 | BitfieldEntry("version", slice(0, 8)), 9 | BitfieldEntry("xAngRateValid", 8), 10 | BitfieldEntry("yAngRateValid", 9), 11 | BitfieldEntry("zAngRateValid", 10), 12 | BitfieldEntry("xAccelValid", 11), 13 | BitfieldEntry("yAccelValid", 12), 14 | BitfieldEntry("zAccelValid", 13), 15 | ]) 16 | 17 | payload_description0 = Fields( 18 | ("bitfield0", bitfield0), 19 | ("reserved1", 4*U1), 20 | ("iTOW", U4), 21 | ("xAngRate", I4), 22 | ("yAngRate", I4), 23 | ("zAngRate", I4), 24 | ("xAccel", I4), 25 | ("yAccel", I4), 26 | ("zAccel", I4), 27 | ) 28 | 29 | description = MessageDescription( 30 | message_class=ESF, 31 | message_id=MessageId("INS", b"\x15"), 32 | payload_description=Options( 33 | Empty, 34 | payload_description0, 35 | ) 36 | ) 37 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_odo.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(1, entries=[ 8 | BitfieldEntry("useODO", 0), 9 | BitfieldEntry("useCOG", 1), 10 | BitfieldEntry("outLPVel", 2), 11 | BitfieldEntry("outLPCog", 3) 12 | ]) 13 | 14 | odoCfg = Bitfield(1, entries=[ 15 | BitfieldEntry("profile", slice(0, 3)), 16 | ]) 17 | 18 | payload_description0 = Fields( 19 | ("version", U1), 20 | ("reserved1", 3*U1), 21 | ("flags", flags), 22 | ("odoCfg", odoCfg), 23 | ("reserved2", 6*U1), 24 | ("cogMaxSpeed", U1), 25 | ("cogMaxPosAcc", U1), 26 | ("reserved3", 2*U1), 27 | ("velLpGain", U1), 28 | ("cogLpGain", U1), 29 | ("reserved4", 2*U1) 30 | ) 31 | 32 | description = MessageDescription( 33 | message_class=CFG, 34 | message_id=MessageId("ODO", b"\x1e"), 35 | payload_description=Options( 36 | Empty, 37 | payload_description0 38 | ) 39 | ) 40 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_sol.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(1, entries=[ 8 | BitfieldEntry("gnssFixOK", 0), 9 | BitfieldEntry("diffSoln", 1), 10 | BitfieldEntry("WKNSET", 2), 11 | BitfieldEntry("TOWSET", 3) 12 | ]) 13 | 14 | payload_description0 = Fields( 15 | ("iTOW", U4), 16 | ("fTOW", I4), 17 | ("week", I2), 18 | ("gpsFix", U1), 19 | ("flags", flags), 20 | ("ecefX", I4), 21 | ("ecefY", I4), 22 | ("ecefZ", I4), 23 | ("pAcc", U4), 24 | ("ecefVX", I4), 25 | ("ecefVY", I4), 26 | ("ecefVZ", I4), 27 | ("sAcc", U4), 28 | ("pDOP", U2), 29 | ("reserved1", U1), 30 | ("numSv", U1), 31 | ("reserved2", 4*U1) 32 | ) 33 | 34 | description = MessageDescription( 35 | message_class=NAV, 36 | message_id=MessageId("SOL", b"\x06"), 37 | payload_description=Options( 38 | Empty, 39 | payload_description0, 40 | ) 41 | ) 42 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_dosc.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(2, [ 8 | BitfieldEntry("isCalibrated", 0), 9 | BitfieldEntry("controlIf", slice(1, 5)) 10 | ]) 11 | 12 | osc = Fields( 13 | ("oscId", U1), 14 | ("reserved2", U1), 15 | ("flags", flags), 16 | ("freq", U4), 17 | ("phaseOffset", I4), 18 | ("withTemp", U4), 19 | ("withAge", U4), 20 | ("timeToTemp", U2), 21 | ("reserved3", 2*U1), 22 | ("gainVco", I4), 23 | ("gainUncertainty", U1), 24 | ("reserved4", 3*U1), 25 | ) 26 | 27 | payload_description0 = Fields( 28 | ("version", U1), 29 | ("numOsc", U1), 30 | ("reserved1", 2*U1), 31 | ("osc", KeyLoop("numOsc", osc)) 32 | ) 33 | 34 | description = MessageDescription( 35 | message_class=CFG, 36 | message_id=MessageId("DOSC", b"\x61"), 37 | payload_description=Options( 38 | Empty, 39 | payload_description0, 40 | ) 41 | ) 42 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_esrc.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(2, [ 8 | BitfieldEntry("polarity", 0), 9 | BitfieldEntry("gnssUtc", 1) 10 | ]) 11 | 12 | sources = Fields( 13 | ("extInt", U1), 14 | ("sourceType", U1), 15 | ("flags", flags), 16 | ("freq", U4), 17 | ("reserved2", 4*U1), 18 | ("withTemp", U4), 19 | ("withAge", U4), 20 | ("timeToTemp", U2), 21 | ("maxDevLifeTime", U2), 22 | ("offset", I4), 23 | ("offsetUncertainty", U4), 24 | ("jitter", U4), 25 | ) 26 | 27 | payload_description0 = Fields( 28 | ("version", U1), 29 | ("numSources", U1), 30 | ("reserved1", 2*U1), 31 | ("sources", KeyLoop("numSources", sources)) 32 | ) 33 | 34 | description = MessageDescription( 35 | message_class=CFG, 36 | message_id=MessageId("ESRC", b"\x60"), 37 | payload_description=Options( 38 | Empty, 39 | payload_description0, 40 | ) 41 | ) 42 | -------------------------------------------------------------------------------- /ubx/descriptions/aid_hui.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(4, entries=[ 8 | BitfieldEntry("healthValid", 0), 9 | BitfieldEntry("utcValid", 1), 10 | BitfieldEntry("klobValid", 2) 11 | ]) 12 | 13 | payload_description0 = Fields( 14 | ("health", X4), 15 | ("utcA0", R8), 16 | ("utcA1", R8), 17 | ("utcTOW", I4), 18 | ("utcWNT", I2), 19 | ("utcLS", I2), 20 | ("utcWNF", I2), 21 | ("utcDN", I2), 22 | ("utcLSF", I2), 23 | ("utcSpare", I2), 24 | ("klobA0", R4), 25 | ("klobA1", R4), 26 | ("klobA2", R4), 27 | ("klobA3", R4), 28 | ("klobB0", R4), 29 | ("klobB1", R4), 30 | ("klobB2", R4), 31 | ("klobB3", R4), 32 | ("flags", flags) 33 | ) 34 | 35 | description = MessageDescription( 36 | message_class=AID, 37 | message_id=MessageId("HUI", b"\x02"), 38 | payload_description=Options( 39 | Empty, 40 | payload_description0 41 | ) 42 | ) 43 | -------------------------------------------------------------------------------- /ubx/descriptions/mon_hw.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(1, ( 8 | BitfieldEntry("rtcCalib", 0), 9 | BitfieldEntry("safeBoot", 1), 10 | BitfieldEntry("jammingState", slice(2, 4)), 11 | BitfieldEntry("xtalAbsent", 4), 12 | ) 13 | ) 14 | 15 | payload_description = Fields( 16 | ("pinSel", X4), 17 | ("pinBank", X4), 18 | ("pinDir", X4), 19 | ("pinVal", X4), 20 | ("noisePerMS", U2), 21 | ("agcCnt", U2), 22 | ("aStatus", U1), 23 | ("aPower", U1), 24 | ("flags", flags), 25 | ("reserved1", U1), 26 | ("usedMask", X4), 27 | ("VP", 17*U1), 28 | ("jamInd", U1), 29 | ("reserved2", U2), 30 | ("pinIrq", X4), 31 | ("pullH", X4), 32 | ("pullL", X4) 33 | ) 34 | 35 | description = MessageDescription( 36 | message_class=MON, 37 | message_id=MessageId("HW", b"\x09"), 38 | payload_description=Options( 39 | Empty, 40 | payload_description 41 | ) 42 | ) 43 | -------------------------------------------------------------------------------- /ubx/descriptions/rxm_svsi.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | svFlag = Bitfield(1, entries=[ 8 | BitfieldEntry("ura", slice(0, 4)), 9 | BitfieldEntry("healthy", 4), 10 | BitfieldEntry("ephVal", 5), 11 | BitfieldEntry("almVal", 6), 12 | BitfieldEntry("notAvail", 7) 13 | ]) 14 | 15 | age = Bitfield(1, entries=[ 16 | BitfieldEntry("almAge", slice(0, 4)), 17 | BitfieldEntry("ephAge", slice(4, 8)), 18 | ]) 19 | 20 | sv = Fields( 21 | ("svid", U1), 22 | ("svFlag", svFlag), 23 | ("azim", I2), 24 | ("elev", I1), 25 | ("age", age) 26 | ) 27 | 28 | payload_description = Fields( 29 | ("iTOW", U4), 30 | ("week", I2), 31 | ("numVis", U1), 32 | ("numSV", U1), 33 | ("svs", KeyLoop("numSV", sv)) 34 | ) 35 | 36 | description = MessageDescription( 37 | message_class=RXM, 38 | message_id=MessageId("SVSI", b"\x20"), 39 | payload_description=Options( 40 | Empty, 41 | payload_description 42 | ) 43 | ) 44 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_sbas.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | service = Bitfield(1, entries=[ 8 | BitfieldEntry("Ranging", 0), 9 | BitfieldEntry("Corrections", 1), 10 | BitfieldEntry("Integrity", 2), 11 | BitfieldEntry("Testmode", 3), 12 | ]) 13 | 14 | svs_fields = Fields( 15 | ("svid", U1), 16 | ("flags", U1), 17 | ("udre", U1), 18 | ("svSys", U1), 19 | ("svService", U1), 20 | ("reserved2", U1), 21 | ("prc", I2), 22 | ("reserved3", 2*U1), 23 | ("ic", I2), 24 | ) 25 | 26 | payload_description = Fields( 27 | ("iTOW", U4), 28 | ("geo", U1), 29 | ("mode", U1), 30 | ("sys", I1), 31 | ("service", service), 32 | ("cnt", U1), 33 | ("reserved1", 3*U1), 34 | ("svs", KeyLoop("cnt", svs_fields)) 35 | ) 36 | 37 | description = MessageDescription( 38 | message_class=NAV, 39 | message_id=MessageId("SBAS", b"\x32"), 40 | payload_description=Options( 41 | Empty, 42 | payload_description 43 | ) 44 | ) 45 | -------------------------------------------------------------------------------- /ubx/descriptions/rxm_pmreq.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags_0 = Bitfield(4, [ 8 | BitfieldEntry("backup", 1) 9 | ]) 10 | 11 | payload_description0 = Fields( 12 | ("duration", U4), 13 | ("flags", flags_0), 14 | ) 15 | 16 | 17 | flags_1 = Bitfield(4, [ 18 | BitfieldEntry("backup", 1), 19 | BitfieldEntry("force", 2) 20 | ]) 21 | 22 | wakeupSources = Bitfield(4, [ 23 | BitfieldEntry("uartrx", 3), 24 | BitfieldEntry("extint0", 5), 25 | BitfieldEntry("extint1", 6), 26 | BitfieldEntry("spics", 7) 27 | ]) 28 | 29 | payload_description1 = Fields( 30 | ("version", U1), 31 | ("reserved1", 3*U1), 32 | ("duration", U4), 33 | ("flags", flags_1), 34 | ("wakeupSources", wakeupSources) 35 | ) 36 | 37 | description = MessageDescription( 38 | message_class=RXM, 39 | message_id=MessageId("PMREQ", b"\x41"), 40 | payload_description=Options( 41 | Empty, 42 | payload_description0, 43 | payload_description1 44 | ) 45 | ) 46 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_status.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(1, ( 8 | BitfieldEntry("gpsFixOk", 0), 9 | BitfieldEntry("diffSoln", 1), 10 | BitfieldEntry("wknSet", 2), 11 | BitfieldEntry("towSet", 3), 12 | BitfieldEntry("reserved", slice(4, 8)) 13 | ) 14 | ) 15 | 16 | fixStat = Bitfield(1, ( 17 | BitfieldEntry("diffCor", 0), 18 | BitfieldEntry("mapMatching", slice(6, 8)) 19 | ) 20 | ) 21 | 22 | flags2 = Bitfield(1, ( 23 | BitfieldEntry("psmState", slice(0, 2)), 24 | BitfieldEntry("spoofDetState", slice(3, 5)), 25 | ) 26 | ) 27 | 28 | payload_description0 = Fields( 29 | ("iTOW", U4), 30 | ("gpsFix", U1), 31 | ("flags", flags), 32 | ("fixStat", fixStat), 33 | ("flags2", flags2), 34 | ("ttff", U4), 35 | ("msss", U4), 36 | ) 37 | 38 | description = MessageDescription( 39 | message_class=NAV, 40 | message_id=MessageId("STATUS", b"\x03"), 41 | payload_description=Options( 42 | Empty, 43 | payload_description0, 44 | ) 45 | ) 46 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_relposned.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(4, entries=[ 8 | BitfieldEntry("gnssFixOK", 0), 9 | BitfieldEntry("diffSoln", 1), 10 | BitfieldEntry("relPosValid", 2), 11 | BitfieldEntry("carrSoln", slice(3, 5)), 12 | BitfieldEntry("isMoving", 5), 13 | BitfieldEntry("refPosMiss", 6), 14 | BitfieldEntry("refObsMiss", 7) 15 | ]) 16 | 17 | payload_description0 = Fields( 18 | ("version", U1), 19 | ("reserved1", U1), 20 | ("refStationId", U2), 21 | ("iTOW", U4), 22 | ("relPosN", I4), 23 | ("relPosE", I4), 24 | ("relPosD", I4), 25 | ("relPosHPN", I1), 26 | ("relPosHPE", I1), 27 | ("relPosHPD", I1), 28 | ("reserved2", U1), 29 | ("accN", U4), 30 | ("accE", U4), 31 | ("accD", U4), 32 | ("flags", flags) 33 | ) 34 | 35 | description = MessageDescription( 36 | message_class=NAV, 37 | message_id=MessageId("RELPOSNED", b"\x3c"), 38 | payload_description=Options( 39 | Empty, 40 | payload_description0, 41 | ) 42 | ) 43 | -------------------------------------------------------------------------------- /ubx/descriptions/mon_gnss.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | supported = Bitfield(1, entries=[ 8 | BitfieldEntry("GPSSup", 0), 9 | BitfieldEntry("GlonassSup", 1), 10 | BitfieldEntry("BeidouSup", 2), 11 | BitfieldEntry("GalileoSup", 3) 12 | ]) 13 | 14 | defaultGnss = Bitfield(1, entries=[ 15 | BitfieldEntry("GPSDef", 0), 16 | BitfieldEntry("GlonassDef", 1), 17 | BitfieldEntry("BeidouDef", 2), 18 | BitfieldEntry("GalileoDef", 3) 19 | ]) 20 | 21 | enabled = Bitfield(1, entries=[ 22 | BitfieldEntry("GPSEna", 0), 23 | BitfieldEntry("GlonassEna", 1), 24 | BitfieldEntry("BeidouEna", 2), 25 | BitfieldEntry("GalileoEna", 3) 26 | ]) 27 | 28 | payload_description = Fields( 29 | ("version", U1), 30 | ("supported", supported), 31 | ("defaultGnss", defaultGnss), 32 | ("enabled", enabled), 33 | ("simultaneous", U1), 34 | ("reserved1", 3*U1), 35 | ) 36 | 37 | description = MessageDescription( 38 | message_class=MON, 39 | message_id=MessageId("GNSS", b"\x28"), 40 | payload_description=Options( 41 | Empty, 42 | payload_description 43 | ) 44 | ) 45 | -------------------------------------------------------------------------------- /ubx/message_id.py: -------------------------------------------------------------------------------- 1 | """UBX message ids""" 2 | 3 | from . import utils 4 | 5 | 6 | class MessageId: 7 | """ 8 | Simple class storing the name and byte of a UBX message id. 9 | """ 10 | def __init__(self, name, byte, subname=None): 11 | if not isinstance(byte, bytes): 12 | raise TypeError("byte argument has to be of type \"byte\" but is: {}".format( 13 | type(byte))) 14 | self.name = name 15 | self.subname = subname 16 | self.byte = byte 17 | 18 | def __eq__(self, other): 19 | if isinstance(other, MessageId): 20 | return self.name==other.name\ 21 | and self.subname==other.subname\ 22 | and self.byte==other.byte 23 | else: 24 | return NotImplemented 25 | 26 | def __ne__(self, other): 27 | return not self==other 28 | 29 | def __str__(self): 30 | bytestring = utils.byte2hexstring(self.byte) 31 | if self.subname is None: 32 | return "MessageId(name={}, byte=0x{})".format(self.name, bytestring) 33 | else: 34 | return "MessageId(name={}, subname={}, byte=0x{})".format( 35 | self.name, self.subname, bytestring) 36 | -------------------------------------------------------------------------------- /ubx/descriptions/log_info.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | status = Bitfield(1, entries=[ 8 | BitfieldEntry("recording", 3), 9 | BitfieldEntry("inactive", 4), 10 | BitfieldEntry("circular", 5) 11 | ]) 12 | 13 | payload_description = Fields( 14 | ("version", U1), 15 | ("reserved1", 3*U1), 16 | ("filestoreCapacity", U4), 17 | ("reserved2", 8*U1), 18 | ("currentMaxLogSize", U4), 19 | ("currentLogSize", U4), 20 | ("entryCount", U4), 21 | ("oldestYear", U2), 22 | ("oldestMonth", U1), 23 | ("oldestDay", U1), 24 | ("oldestHour", U1), 25 | ("oldestMinute", U1), 26 | ("oldestSecond", U1), 27 | ("reserved3", U1), 28 | ("newestYear", U2), 29 | ("newestMonth", U1), 30 | ("newestDay", U1), 31 | ("newestHour", U1), 32 | ("newestMinute", U1), 33 | ("newestSecond", U1), 34 | ("reserved4", U1), 35 | ("status", status), 36 | ("reserved5", 3*U1) 37 | ) 38 | 39 | description = MessageDescription( 40 | message_class=LOG, 41 | message_id=MessageId("INFO", b"\x08"), 42 | payload_description=Options( 43 | Empty, 44 | payload_description 45 | ) 46 | ) 47 | -------------------------------------------------------------------------------- /ubx/descriptions/aid_ini.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | tmCfg = Bitfield(2, [ 8 | BitfieldEntry("fEdge", 1), 9 | BitfieldEntry("tm1", 4), 10 | BitfieldEntry("f1", 6) 11 | ]) 12 | 13 | flags = Bitfield(4, [ 14 | BitfieldEntry("pos", 0), 15 | BitfieldEntry("time", 1), 16 | BitfieldEntry("clockD", 2), 17 | BitfieldEntry("tp", 3), 18 | BitfieldEntry("clockF", 4), 19 | BitfieldEntry("lla", 5), 20 | BitfieldEntry("altInv", 6), 21 | BitfieldEntry("prevTm", 7), 22 | BitfieldEntry("utc", 10), 23 | ]) 24 | 25 | payload_description0 = Fields( 26 | ("ecefXOrLat", I4), 27 | ("ecefYOrLon", I4), 28 | ("ecefZOrAlt", I4), 29 | ("posAcc", U4), 30 | ("tmCfg", tmCfg), 31 | ("wnoOrDate", U2), 32 | ("towOrTime", U4), 33 | ("towNs", I4), 34 | ("tAccMs", U4), 35 | ("tAccNs", U4), 36 | ("clkDOrFreq", I4), 37 | ("clkDAccOrFreqAcc", U4), 38 | ("flags", flags) 39 | ) 40 | 41 | 42 | description = MessageDescription( 43 | message_class=AID, 44 | message_id=MessageId("INI", b"\x01"), 45 | payload_description=Options( 46 | Empty, 47 | payload_description0, 48 | ) 49 | ) 50 | -------------------------------------------------------------------------------- /ubx/descriptions/rxm_measx.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(1, [ 8 | BitfieldEntry("towSet", slice(0, 2)) 9 | ]) 10 | 11 | sv = Fields( 12 | ("gnssId", U1), 13 | ("svId", U1), 14 | ("cNo", U1), 15 | ("mpathIndic", U1), 16 | ("dopplerMS", I4), 17 | ("dopplerHz", I4), 18 | ("wholeChips", U2), 19 | ("fracChips", U2), 20 | ("codePhase", U4), 21 | ("intCodePhase", U1), 22 | ("pseuRangeRMSErr", U1), 23 | ("reserved5", 2*U1) 24 | ) 25 | 26 | payload_description0 = Fields( 27 | ("version", U1), 28 | ("reserved1", 3*U1), 29 | ("gpsTOW", U4), 30 | ("gloTOW", U4), 31 | ("bdsTOW", U4), 32 | ("reserved2", 4*U1), 33 | ("qzssTOW", U4), 34 | ("gpsTOWacc", U2), 35 | ("gloTOWacc", U2), 36 | ("bdsTOWacc", U2), 37 | ("reserved3", 2*U1), 38 | ("qzssTOWacc", U2), 39 | ("numSV", U1), 40 | ("flags", flags), 41 | ("reserved4", 8*U1), 42 | ("svs", KeyLoop("numSV", sv)) 43 | ) 44 | 45 | description = MessageDescription( 46 | message_class=RXM, 47 | message_id=MessageId("MEASX", b"\x14"), 48 | payload_description=Options( 49 | Empty, 50 | payload_description0, 51 | ) 52 | ) 53 | -------------------------------------------------------------------------------- /ubx/descriptions/esf_status.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | sensStatus1 = Bitfield(1, entries=[ 8 | BitfieldEntry("type", slice(0, 6)), 9 | BitfieldEntry("used", 6), 10 | BitfieldEntry("ready", 7), 11 | ]) 12 | 13 | sensStatus2 = Bitfield(1, entries=[ 14 | BitfieldEntry("calibStatus", slice(0, 2)), 15 | BitfieldEntry("timeStatus", slice(2, 4)) 16 | ]) 17 | 18 | faults = Bitfield(1, entries=[ 19 | BitfieldEntry("badMeas", 0), 20 | BitfieldEntry("badTTag", 1), 21 | BitfieldEntry("missingMeas", 2), 22 | BitfieldEntry("noisyMeas", 3), 23 | ]) 24 | 25 | sens = Fields( 26 | ("sensStatus1", sensStatus1), 27 | ("sensStatus2", sensStatus2), 28 | ("freq", U1), 29 | ("faults", faults) 30 | ) 31 | 32 | payload_description0 = Fields( 33 | ("iTOW", U4), 34 | ("version", U1), 35 | ("reserved1", 7*U1), 36 | ("fusionMode", U1), 37 | ("reserved2", 2*U1), 38 | ("numSens", U1), 39 | ("sens", KeyLoop("numSens", sens)) 40 | ) 41 | 42 | description = MessageDescription( 43 | message_class=ESF, 44 | message_id=MessageId("STATUS", b"\x10"), 45 | payload_description=Options( 46 | Empty, 47 | payload_description0, 48 | ) 49 | ) 50 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_cfg.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | mask = Bitfield(4, entries=[ 8 | BitfieldEntry("ioPort", 0), 9 | BitfieldEntry("msgConf", 1), 10 | BitfieldEntry("infMsg", 2), 11 | BitfieldEntry("navConf", 3), 12 | BitfieldEntry("rxmConf", 4), 13 | BitfieldEntry("senConf", 8), 14 | BitfieldEntry("rinvConf", 9), 15 | BitfieldEntry("antConf", 10), 16 | BitfieldEntry("logConf", 11), 17 | BitfieldEntry("ftsConf", 12) 18 | ]) 19 | 20 | deviceMask = Bitfield(1, entries=[ 21 | BitfieldEntry("devBBR", 0), 22 | BitfieldEntry("devFlash", 1), 23 | BitfieldEntry("devEEPROM", 2), 24 | BitfieldEntry("devSpiFlash", 4) 25 | ]) 26 | 27 | payload_description0 = Fields( 28 | ("clearMask", mask), 29 | ("saveMask", mask), 30 | ("loadMask", mask) 31 | ) 32 | 33 | payload_description1 = Fields( 34 | ("clearMask", mask), 35 | ("saveMask", mask), 36 | ("loadMask", mask), 37 | ("deviceMask", deviceMask) 38 | ) 39 | 40 | description = MessageDescription( 41 | message_class=CFG, 42 | message_id=MessageId("CFG", b"\x09"), 43 | payload_description=Options( 44 | payload_description0, 45 | payload_description1, 46 | ) 47 | ) 48 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_orb.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | svFlag = Bitfield(1, entries=[ 8 | BitfieldEntry("health", slice(0, 2)), 9 | BitfieldEntry("visibility", slice(2, 4)) 10 | ]) 11 | 12 | eph = Bitfield(1, entries=[ 13 | BitfieldEntry("ephUsability", slice(0, 5)), 14 | BitfieldEntry("ephSource", slice(5, 8)) 15 | ]) 16 | 17 | alm = Bitfield(1, entries=[ 18 | BitfieldEntry("almUsability", slice(0, 5)), 19 | BitfieldEntry("almSource", slice(5, 8)) 20 | ]) 21 | 22 | otherOrb = Bitfield(1, entries=[ 23 | BitfieldEntry("anoAopUsability", slice(0, 5)), 24 | BitfieldEntry("type", slice(5, 8)) 25 | ]) 26 | 27 | sv = Fields( 28 | ("gnssId", U1), 29 | ("svId", U1), 30 | ("svFlag", svFlag), 31 | ("eph", eph), 32 | ("alm", alm), 33 | ("otherOrb", otherOrb) 34 | ) 35 | 36 | payload_description0 = Fields( 37 | ("iTOW", U4), 38 | ("version", U1), 39 | ("numSv", U1), 40 | ("reserved1", 2*U1), 41 | ("svs", KeyLoop("numSv", sv)) 42 | ) 43 | 44 | description = MessageDescription( 45 | message_class=NAV, 46 | message_id=MessageId("ORB", b"\x34"), 47 | payload_description=Options( 48 | Empty, 49 | payload_description0, 50 | ) 51 | ) 52 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_svinfo.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | globalFlags = Bitfield(1, ( 8 | BitfieldEntry("chipGen", slice(0, 3)), 9 | ) 10 | ) 11 | 12 | flags = Bitfield(1, ( 13 | BitfieldEntry("svUsed", 0), 14 | BitfieldEntry("diffCorr", 1), 15 | BitfieldEntry("orbitAvail", 2), 16 | BitfieldEntry("orbitEph", 3), 17 | BitfieldEntry("unhealthy", 4), 18 | BitfieldEntry("orbitAlm", 5), 19 | BitfieldEntry("orbitAop", 6), 20 | BitfieldEntry("smoothed", 7), 21 | ) 22 | ) 23 | 24 | quality = Bitfield(1, ( 25 | BitfieldEntry("qualityInd", slice(0, 4)), 26 | ) 27 | ) 28 | 29 | chn_fields = Fields( 30 | ("chn", U1), 31 | ("svid", U1), 32 | ("flags", flags), 33 | ("quality", quality), 34 | ("cno", U1), 35 | ("elev", I1), 36 | ("azim", I2), 37 | ("prRes", I4) 38 | ) 39 | 40 | payload_description0 = Fields( 41 | ("iTOW", U4), 42 | ("numCh", U1), 43 | ("globalFlags", globalFlags), 44 | ("reserved1", 2*U1), 45 | ("ch", KeyLoop("numCh", chn_fields)), 46 | ) 47 | 48 | description = MessageDescription( 49 | message_class=NAV, 50 | message_id=MessageId("SVINFO", b"\x30"), 51 | payload_description=Options( 52 | Empty, 53 | payload_description0, 54 | ) 55 | ) 56 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_nav5.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | mask = Bitfield(2, entries=[ 8 | BitfieldEntry("dyn", 0), 9 | BitfieldEntry("minEl", 1), 10 | BitfieldEntry("posFixMode", 2), 11 | BitfieldEntry("drLim", 3), 12 | BitfieldEntry("posMask", 4), 13 | BitfieldEntry("timeMask", 5), 14 | BitfieldEntry("staticHoldMask", 6), 15 | BitfieldEntry("dgpsMask", 7), 16 | BitfieldEntry("cnoThreshold", 8), 17 | BitfieldEntry("utc", 10), 18 | ]) 19 | 20 | payload_description0 = Fields( 21 | ("mask", mask), 22 | ("dynModel", U1), 23 | ("fixMode", U1), 24 | ("fixedAlt", I4), 25 | ("fixedAltVar", U4), 26 | ("minElev", I1), 27 | ("drLimit", U1), 28 | ("pDop", U2), 29 | ("tDop", U2), 30 | ("pAcc", U2), 31 | ("tAcc", U2), 32 | ("staticHoldThresh", U1), 33 | ("dgnssTimeout", U1), 34 | ("cnoThreshNumSVs", U1), 35 | ("cnoThresh", U1), 36 | ("reserved1", 2*U1), 37 | ("staticHoldMaxDist", U2), 38 | ("utcStandard", U1), 39 | ("reserved2", 5*U1) 40 | ) 41 | 42 | description = MessageDescription( 43 | message_class=CFG, 44 | message_id=MessageId("NAV5", b"\x24"), 45 | payload_description=Options( 46 | Empty, 47 | payload_description0 48 | ) 49 | ) 50 | -------------------------------------------------------------------------------- /test/test_message_id.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | 3 | import ubx 4 | 5 | 6 | class TestMessageId(unittest.TestCase): 7 | def test_creation(self): 8 | m = ubx.MessageId("TEST", b"\x01") 9 | self.assertEqual(m.name, "TEST") 10 | self.assertEqual(m.byte, b"\x01") 11 | 12 | with self.assertRaises(TypeError): 13 | ubx.MessageId("TEST", 1) 14 | 15 | def test_equality(self): 16 | m0 = ubx.MessageId("TEST", b"\x01") 17 | m1 = ubx.MessageId("TEST", b"\x01") 18 | m2 = ubx.MessageId("TEST", b"\x01", "SUB") 19 | m3 = ubx.MessageId("TEST", b"\x02") 20 | self.assertTrue(m0==m0) 21 | self.assertTrue(m0==m1) 22 | self.assertTrue(m2==m2) 23 | self.assertTrue(m3==m3) 24 | self.assertFalse(m0!=m0) 25 | self.assertFalse(m0!=m1) 26 | self.assertFalse(m2!=m2) 27 | self.assertFalse(m3!=m3) 28 | 29 | self.assertFalse(m0==m2) 30 | self.assertFalse(m0==m3) 31 | self.assertTrue(m0!=m2) 32 | self.assertTrue(m0!=m3) 33 | 34 | def test_repr(self): 35 | m = ubx.MessageId("TEST", b"\x01") 36 | self.assertEqual(str(m), "MessageId(name=TEST, byte=0x01)") 37 | m = ubx.MessageId("TEST", b"\x01", "SUB") 38 | self.assertEqual(str(m), "MessageId(name=TEST, subname=SUB, byte=0x01)") 39 | 40 | 41 | if __name__ == '__main__': 42 | unittest.main() 43 | -------------------------------------------------------------------------------- /ubx/descriptions/hnr_pvt.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | valid = Bitfield(1, entries=[ 8 | BitfieldEntry("validDate", 0), 9 | BitfieldEntry("validTime", 1), 10 | BitfieldEntry("fullyResolved", 2) 11 | ]) 12 | 13 | flags = Bitfield(1, entries=[ 14 | BitfieldEntry("GPSfixOK", 0), 15 | BitfieldEntry("DiffSoln", 1), 16 | BitfieldEntry("WKNSET", 2), 17 | BitfieldEntry("TOWSET", 3), 18 | BitfieldEntry("headVehValid", 4) 19 | ]) 20 | 21 | payload_description0 = Fields( 22 | ("iTOW", U4), 23 | ("year", U2), 24 | ("month", U1), 25 | ("day", U1), 26 | ("hour", U1), 27 | ("min", U1), 28 | ("sec", U1), 29 | ("valid", valid), 30 | ("nano", I4), 31 | ("gpsFix", U1), 32 | ("flags", flags), 33 | ("reserved1", 2*U1), 34 | ("lon", I4), 35 | ("lat", I4), 36 | ("height", I4), 37 | ("hMSL", I4), 38 | ("gSpeed", I4), 39 | ("speed", I4), 40 | ("headMot", I4), 41 | ("headVeh", I4), 42 | ("hAcc", U4), 43 | ("vAcc", U4), 44 | ("sAcc", U4), 45 | ("headAcc", U4), 46 | ("reserved2", 4*U1) 47 | ) 48 | 49 | description = MessageDescription( 50 | message_class=HNR, 51 | message_id=MessageId("PVT", b"\x00"), 52 | payload_description=Options( 53 | Empty, 54 | payload_description0, 55 | ) 56 | ) 57 | -------------------------------------------------------------------------------- /ubx/descriptions/nav_sat.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(4, ( 8 | BitfieldEntry("qualityInd", slice(0, 3)), 9 | BitfieldEntry("svUsed", 3), 10 | BitfieldEntry("health", slice(4, 6)), 11 | BitfieldEntry("diffCor", 6), 12 | BitfieldEntry("smoothed", 7), 13 | BitfieldEntry("orbitSource", slice(8, 11)), 14 | BitfieldEntry("ephAvail", 11), 15 | BitfieldEntry("almAvail", 12), 16 | BitfieldEntry("anoAvail", 13), 17 | BitfieldEntry("aopAvail", 14), 18 | BitfieldEntry("sbasCorrUsed", 16), 19 | BitfieldEntry("rtcmCorrUsed", 17), 20 | BitfieldEntry("prCorrUsed", 20), 21 | BitfieldEntry("crCorrUsed", 21), 22 | BitfieldEntry("doCorrUsed", 22), 23 | ) 24 | ) 25 | 26 | svs_fields = Fields( 27 | ("gnssId", U1), 28 | ("svId", U1), 29 | ("cno", U1), 30 | ("elev", I1), 31 | ("azim", I2), 32 | ("prRes", I2), 33 | ("flags", flags), 34 | ) 35 | 36 | payload_description = Fields( 37 | ("iTOW", U4), 38 | ("version", U1), 39 | ("numSvs", U1), 40 | ("reserved1", 2*U1), 41 | ("meas", KeyLoop("numSvs", svs_fields)) 42 | ) 43 | 44 | description = MessageDescription( 45 | message_class=NAV, 46 | message_id=MessageId("SAT", b"\x35"), 47 | payload_description=Options( 48 | Empty, 49 | payload_description 50 | ) 51 | ) 52 | -------------------------------------------------------------------------------- /ubx/descriptions/mon_smgr.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | intOsc = Bitfield(2, entries=[ 8 | BitfieldEntry("intOscState", slice(0, 4)), 9 | BitfieldEntry("intOscCalib", 4), 10 | BitfieldEntry("intOscDisc", 5) 11 | ]) 12 | 13 | extOsc = Bitfield(2, entries=[ 14 | BitfieldEntry("extOscState", slice(0, 4)), 15 | BitfieldEntry("extOscCalib", 4), 16 | BitfieldEntry("extOscDisc", 5) 17 | ]) 18 | 19 | gnss = Bitfield(1, entries=[ 20 | BitfieldEntry("gnssAvail", 0) 21 | ]) 22 | 23 | extInt0 = Bitfield(1, entries=[ 24 | BitfieldEntry("extInt0Avail", 0), 25 | BitfieldEntry("extInt0Type", 1), 26 | BitfieldEntry("extInt0FeedBack", 2) 27 | ]) 28 | 29 | extInt1 = Bitfield(1, entries=[ 30 | BitfieldEntry("extInt1Avail", 0), 31 | BitfieldEntry("extInt1Type", 1), 32 | BitfieldEntry("extInt1FeedBack", 2) 33 | ]) 34 | 35 | payload_description = Fields( 36 | ("version", U1), 37 | ("reserved1", 3*U1), 38 | ("iTOW", U4), 39 | ("intOsc", intOsc), 40 | ("extOsc", extOsc), 41 | ("discSrc", U1), 42 | ("gnss", gnss), 43 | ("extInt0", extInt0), 44 | ("extInt1", extInt1) 45 | ) 46 | 47 | description = MessageDescription( 48 | message_class=MON, 49 | message_id=MessageId("SMGR", b"\x2e"), 50 | payload_description=Options( 51 | Empty, 52 | payload_description 53 | ) 54 | ) 55 | -------------------------------------------------------------------------------- /ubx/descriptions/tim_tos.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | flags = Bitfield(4, entries=[ 8 | BitfieldEntry("leapNow", 0), 9 | BitfieldEntry("leapSoon", 1), 10 | BitfieldEntry("leapPositive", 2), 11 | BitfieldEntry("timeInLimit", 3), 12 | BitfieldEntry("intOscInLimit", 4), 13 | BitfieldEntry("extOscInLimit", 5), 14 | BitfieldEntry("gnssTimeValid", 6), 15 | BitfieldEntry("UTCTimeValid", 7), 16 | BitfieldEntry("DiscSrc", slice(8, 11)), 17 | BitfieldEntry("raim", 11), 18 | BitfieldEntry("cohPulse", 12), 19 | BitfieldEntry("lockedPulse", 13), 20 | ]) 21 | 22 | payload_description = Fields( 23 | ("version", U1), 24 | ("gnssId", U1), 25 | ("reserved1", 2*U1), 26 | ("flags", flags), 27 | ("year", U2), 28 | ("month", U1), 29 | ("day", U1), 30 | ("hour", U1), 31 | ("minute", U1), 32 | ("second", U1), 33 | ("utcStandard", U1), 34 | ("utcOffset", I4), 35 | ("utcUncertainty", U4), 36 | ("week", U4), 37 | ("TOW", U4), 38 | ("gnssOffset", I4), 39 | ("gnssUncertainty", U4), 40 | ("intOscOffset", I4), 41 | ("intOscUncertainty", U4), 42 | ("extOscOffset", I4), 43 | ("extOscUncertainty", U4) 44 | ) 45 | 46 | description = MessageDescription( 47 | message_class=TIM, 48 | message_id=MessageId("TOS", b"\x12"), 49 | payload_description=Options( 50 | Empty, 51 | payload_description 52 | ) 53 | ) 54 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_smgr.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | messageCfg = Bitfield(2, entries=[ 8 | BitfieldEntry("measInternal", 0), 9 | BitfieldEntry("measGNSS", 1), 10 | BitfieldEntry("measEXTINT0", 2), 11 | BitfieldEntry("measEXTINT1", 3), 12 | ]) 13 | 14 | flags = Bitfield(2, entries=[ 15 | BitfieldEntry("disableInternal", 0), 16 | BitfieldEntry("disableExternal", 1), 17 | BitfieldEntry("preferenceMode", 2), 18 | BitfieldEntry("enableGNSS", 3), 19 | BitfieldEntry("enableEXTINT0", 4), 20 | BitfieldEntry("enableEXTINT1", 5), 21 | BitfieldEntry("enableHostMeasInt", 6), 22 | BitfieldEntry("enableHostMeasExt", 7), 23 | BitfieldEntry("useAnyFix", 10), 24 | BitfieldEntry("disableMaxSlewRate", 11), 25 | BitfieldEntry("issueFreqWarning", 12), 26 | BitfieldEntry("issueTimeWarning", 13), 27 | BitfieldEntry("TPCoherent", slice(14, 16)), 28 | BitfieldEntry("disableOffset", 16), 29 | 30 | ]) 31 | 32 | payload_description0 = Fields( 33 | ("version", U1), 34 | ("miGNSSFix", U1), 35 | ("maxFreqChangeRate", U2), 36 | ("maxPhaseCorrRate", U2), 37 | ("reserved1", 2*U1), 38 | ("freqTolerance", U2), 39 | ("timeTolerance", U2), 40 | ("messageCfg", messageCfg), 41 | ("maxSlewRate", U2), 42 | ("flags", flags) 43 | ) 44 | 45 | description = MessageDescription( 46 | message_class=CFG, 47 | message_id=MessageId("SMGR", b"\x62"), 48 | payload_description=Options( 49 | Empty, 50 | payload_description0, 51 | ) 52 | ) 53 | -------------------------------------------------------------------------------- /ubx/descriptions/cfg_tp5.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | # flags = Bitfield(4, entries=[ 8 | # BitfieldEntry("active", 0), 9 | # BitfieldEntry("lockGpsFreq", 1), 10 | # BitfieldEntry("lockedOtherSet", 2), 11 | # BitfieldEntry("isFreq", 3), 12 | # BitfieldEntry("isLength", 4), 13 | # BitfieldEntry("alignToTow", 5), 14 | # BitfieldEntry("polarity", 6), 15 | # BitfieldEntry("gridUtcGps", 7), 16 | # ]) 17 | 18 | flags = Bitfield(4, entries=[ 19 | BitfieldEntry("active", 0), 20 | BitfieldEntry("lockGpsFreq", 1), 21 | BitfieldEntry("lockedOtherSet", 2), 22 | BitfieldEntry("isFreq", 3), 23 | BitfieldEntry("isLength", 4), 24 | BitfieldEntry("alignToTow", 5), 25 | BitfieldEntry("polarity", 6), 26 | BitfieldEntry("gridUtcGnss", slice(7, 11)), 27 | BitfieldEntry("syncMode", slice(11, 13)), 28 | ]) 29 | 30 | payload_description0 = Fields( 31 | ("tpIdx", U1) 32 | ) 33 | 34 | payload_description1 = Fields( 35 | ("tpIdx", U1), 36 | ("version", U1), 37 | ("reserved1", 2*U1), 38 | ("antCableDelay", I2), 39 | ("rfGroupDelay", I2), 40 | ("freqPeriod", U4), 41 | ("freqPeriodLock", U4), 42 | ("pulseLenRation", U4), 43 | ("pulseLenRationLock", U4), 44 | ("userConfigDelay", I4), 45 | ("flags", flags) 46 | ) 47 | 48 | description = MessageDescription( 49 | message_class=CFG, 50 | message_id=MessageId("TP5", b"\x31"), 51 | payload_description=Options( 52 | Empty, 53 | payload_description0, 54 | payload_description1, 55 | ) 56 | ) 57 | -------------------------------------------------------------------------------- /ubx/descriptions/rxm_rawx.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | recStat = Bitfield(1, ( 8 | BitfieldEntry("leapSec", 0), 9 | BitfieldEntry("clkReset", 1), 10 | ) 11 | ) 12 | 13 | prStdev = Bitfield(1, ( 14 | BitfieldEntry("prStd", slice(0, 4)), 15 | ) 16 | ) 17 | 18 | cpStdev = Bitfield(1, ( 19 | BitfieldEntry("cpStd", slice(0, 4)), 20 | ) 21 | ) 22 | 23 | doStdev = Bitfield(1, ( 24 | BitfieldEntry("doStd", slice(0, 4)), 25 | ) 26 | ) 27 | 28 | trkStat = Bitfield(1, ( 29 | BitfieldEntry("prValid", 0), 30 | BitfieldEntry("cpValid", 1), 31 | BitfieldEntry("halfCyc", 2), 32 | BitfieldEntry("subHalfCyc", 3), 33 | ) 34 | ) 35 | 36 | meas_fields = Fields( 37 | ("prMes", R8), 38 | ("cpMes", R8), 39 | ("doMes", R4), 40 | ("gnssId", U1), 41 | ("svId", U1), 42 | ("reserved2", U1), 43 | ("freqId", U1), 44 | ("locktime", U2), 45 | ("cno", U1), 46 | ("prStdev", prStdev), 47 | ("cpStdev", cpStdev), 48 | ("doStdev", doStdev), 49 | ("trkStat", trkStat), 50 | ("reserved3", U1) 51 | ) 52 | 53 | payload_description = Fields( 54 | ("rcvTow", R8), 55 | ("week", U2), 56 | ("leapS", I1), 57 | ("numMeas", U1), 58 | ("recStat", recStat), 59 | ("version", U1), 60 | ("reserved1", 2*U1), 61 | ("meas", KeyLoop("numMeas", meas_fields)) 62 | ) 63 | 64 | description = MessageDescription( 65 | message_class=RXM, 66 | message_id=MessageId("RAWX", b"\x15"), 67 | payload_description=Options( 68 | Empty, 69 | payload_description, 70 | ) 71 | ) 72 | -------------------------------------------------------------------------------- /ubx/descriptions/mga_glo.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description_eph = Fields( 8 | ("type", U1), 9 | ("version", U1), 10 | ("svId", U1), 11 | ("reserved1", U1), 12 | ("FT", U1), 13 | ("B", U1), 14 | ("M", U1), 15 | ("H", I1), 16 | ("x", I4), 17 | ("y", I4), 18 | ("z", I4), 19 | ("dx", I4), 20 | ("dy", I4), 21 | ("dz", I4), 22 | ("ddx", I1), 23 | ("ddy", I1), 24 | ("ddz", I1), 25 | ("tb", U1), 26 | ("gamma", I2), 27 | ("E", U1), 28 | ("deltaTau", I1), 29 | ("tau", I4), 30 | ("reserved2", 4*U1) 31 | ) 32 | 33 | payload_description_alm = Fields( 34 | ("type", U1), 35 | ("version", U1), 36 | ("svId", U1), 37 | ("reserved1", U1), 38 | ("N", U2), 39 | ("M", U1), 40 | ("C", U1), 41 | ("tau", I2), 42 | ("epsilon", U2), 43 | ("lambda", I4), 44 | ("deltaI", I4), 45 | ("tLambda", U4), 46 | ("deltaT", I4), 47 | ("deltaDT", I1), 48 | ("H", I1), 49 | ("omega", I2), 50 | ("reserved2", 4*U1) 51 | ) 52 | 53 | payload_description_timeoffset = Fields( 54 | ("type", U1), 55 | ("version", U1), 56 | ("N", U2), 57 | ("tauC", I4), 58 | ("tauGps", I4), 59 | ("B1", I2), 60 | ("B2", I2), 61 | ("reserved1", 4*U1) 62 | ) 63 | 64 | description = MessageDescription( 65 | message_class=MGA, 66 | message_id=MessageId("GLO", b"\x06"), 67 | payload_description=Options( 68 | payload_description_eph, 69 | payload_description_alm, 70 | payload_description_timeoffset 71 | ) 72 | ) 73 | -------------------------------------------------------------------------------- /ubx/descriptions/log_batch.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | contentValid = Bitfield(1, entries=[ 8 | BitfieldEntry("extraPvt", 0), 9 | BitfieldEntry("extraOdo", 1) 10 | ]) 11 | 12 | valid = Bitfield(1, entries=[ 13 | BitfieldEntry("validDate", 0), 14 | BitfieldEntry("validTime", 1) 15 | ]) 16 | 17 | flags = Bitfield(1, entries=[ 18 | BitfieldEntry("gnssFixOK", 0), 19 | BitfieldEntry("diffSoln", 1), 20 | BitfieldEntry("psmState", slice(2, 5)), 21 | ]) 22 | 23 | payload_description = Fields( 24 | ("version", U1), 25 | ("contentValid", contentValid), 26 | ("msgCnt", U2), 27 | ("iTOW", U4), 28 | ("year", U2), 29 | ("month", U1), 30 | ("day", U1), 31 | ("hour", U1), 32 | ("min", U1), 33 | ("sec", U1), 34 | ("valid", valid), 35 | ("tAcc", U4), 36 | ("fracSec", I4), 37 | ("fixType", U1), 38 | ("flags", flags), 39 | ("flags2", X1), 40 | ("numSV", U1), 41 | ("lon", I4), 42 | ("lat", I4), 43 | ("height", I4), 44 | ("hMSL", I4), 45 | ("hAcc", U4), 46 | ("vAcc", U4), 47 | ("velN", I4), 48 | ("velE", I4), 49 | ("velD", I4), 50 | ("gSpeed", I4), 51 | ("headMot", I4), 52 | ("sAcc", U4), 53 | ("headAcc", U4), 54 | ("pDOP", U2), 55 | ("reserved1", 2*U1), 56 | ("distance", U4), 57 | ("totalDistance", U4), 58 | ("distanceStd", U4), 59 | ("reserved2", 4*U1) 60 | ) 61 | 62 | description = MessageDescription( 63 | message_class=LOG, 64 | message_id=MessageId("BATCH", b"\x11"), 65 | payload_description=Options( 66 | Empty, 67 | payload_description 68 | ) 69 | ) 70 | -------------------------------------------------------------------------------- /ubx/rawmessage.py: -------------------------------------------------------------------------------- 1 | import struct 2 | 3 | from . import syncchars 4 | from . import message_class 5 | from . import utils 6 | from . import checksum 7 | 8 | 9 | class RawMessage: 10 | length_struct = struct.Struct(" 0.05: 46 | sys.stdout.write("Bytes read: {}\r".format(stats.bytes_read_success)) 47 | sys.stdout.flush() 48 | self.t = t 49 | return result 50 | else: 51 | def read(self, n): 52 | return self._read(n) 53 | 54 | if args.fast: 55 | reader = ubx.Reader(read_raw) 56 | else: 57 | readwrapper = ReadWrapper(read_raw) 58 | reader = ubx.Reader(readwrapper.read) 59 | 60 | parser = ubx.default_parser 61 | 62 | 63 | def run(): 64 | while True: 65 | try: 66 | rawmessage = reader.read_rawmessage() 67 | except ubx.ChecksumError: 68 | stats.add_checksumerror() 69 | continue 70 | except EOFError: 71 | break 72 | else: 73 | stats.add_rawmessage(rawmessage) 74 | 75 | try: 76 | message = parser.parse(rawmessage) 77 | except KeyError: 78 | stats.add_unknownmessage(rawmessage) 79 | continue 80 | except ubx.PayloadError: 81 | stats.add_payloaderror( 82 | ubx.Message(parser.descriptions[rawmessage.key], None)) 83 | continue 84 | else: 85 | stats.add_message(message) 86 | 87 | 88 | try: 89 | run() 90 | except KeyboardInterrupt: 91 | pass 92 | 93 | if args.progress: 94 | sys.stdout.write(" " * 50 + "\r") 95 | sys.stdout.flush() 96 | 97 | print(stats) 98 | -------------------------------------------------------------------------------- /ubx/checksum.py: -------------------------------------------------------------------------------- 1 | """Checksum using the 8-Bit Fletcher Algorithm with modulo 256.""" 2 | 3 | import sys 4 | import struct 5 | 6 | 7 | if sys.version_info > (3,): 8 | long = int 9 | 10 | 11 | class ChecksumError(Exception): 12 | """Checksums don't match.""" 13 | 14 | def __init__(self, checksum0, checksum1): 15 | Exception.__init__(self, "Checksums differ: {} vs {}".format( 16 | hex(checksum0.a) + hex(checksum0.a), 17 | hex(checksum1.a) + hex(checksum1.b))) 18 | self.checksum0 = checksum0 19 | self.checksum1 = checksum1 20 | 21 | 22 | class Checksum: 23 | """Checksum using a 8-Bit Fletcher algorithm with modulo 256.""" 24 | 25 | checksum_struct = struct.Struct(" (3,): 38 | @staticmethod 39 | def from_bytestrings(*args): 40 | """Calculate a combined Checksum for the given bytestrings.""" 41 | a = 0 42 | b = 0 43 | for arg in args: 44 | for x in arg: 45 | a += x 46 | b += a 47 | return Checksum(a & 0xFF, b & 0xFF) 48 | else: 49 | @staticmethod 50 | def from_bytestrings(*args): 51 | """Calculate a combined Checksum for the given bytestrings.""" 52 | a = 0 53 | b = 0 54 | for arg in args: 55 | for byte in arg: 56 | a += ord(byte) 57 | b += a 58 | return Checksum(a & 0xFF, b & 0xFF) 59 | 60 | def update(self, byte): 61 | """Update the Checksum using te given single byte.""" 62 | self.a = (self.a + ord(byte)) & 0xFF 63 | self.b = (self.b + self.a) & 0xFF 64 | 65 | def __repr__(self): 66 | return "Checksum({}, {})".format(self.a, self.b) 67 | 68 | def __eq__(self, other): 69 | return self.a == other.a and self.b == other.b 70 | 71 | def __ne__(self, other): 72 | return not self == other 73 | 74 | def bytes(self): 75 | """Return a byte representation of this Checksum.""" 76 | return self.checksum_struct.pack(self.a)\ 77 | + self.checksum_struct.pack(self.b) 78 | 79 | def check_equal(self, other): 80 | """Raise a ChecksumError if the two Checksums are not equal.""" 81 | if self != other: 82 | raise ChecksumError(self, other) 83 | -------------------------------------------------------------------------------- /ubx/printing/rst.py: -------------------------------------------------------------------------------- 1 | from .base import DescriptionPrinter 2 | 3 | from .. import utils 4 | from .. import payload 5 | from .. import message 6 | 7 | 8 | class RST(DescriptionPrinter): 9 | def print_MessageDescription(self, obj): 10 | template = ":name: {name}\n\n"\ 11 | ":class: 0x{class}\n\n"\ 12 | ":id: 0x{id}\n\n"\ 13 | ":payload:\n\n {payload}" 14 | return template.format(**{ 15 | "name": obj.name, 16 | "class": utils.byte2hexstring(obj.message_class.byte), 17 | "id": utils.byte2hexstring(obj.message_id.byte), 18 | "payload": self.print_dispatch(obj.payload_description).replace("\n", "\n ") 19 | }) 20 | 21 | 22 | def print_EmptyVariable(self, obj): 23 | return "`Empty`" 24 | 25 | def print_BitfieldEntry(self, obj): 26 | if isinstance(obj.bits, int): 27 | bits = str(obj.bits) 28 | elif isinstance(obj.bits, slice): 29 | bits = "{}:{}".format(obj.bits.start, obj.bits.stop) 30 | else: 31 | bits = str(obj.bits) 32 | return "{bits}: *{name}*".format(name=obj.name, bits=bits) 33 | 34 | def print_Bitfield(self, obj): 35 | header = "Bitfield({})".format(obj.bytesize) 36 | if obj.entries is None: 37 | return header 38 | return header + "\n\n" + "\n\n".join(" " + self.print_BitfieldEntry(entry) for entry in obj.entries) 39 | 40 | def print_AtomicVariable(self, obj): 41 | return obj.name 42 | 43 | def print_Chars(self, obj): 44 | return "Chars({})".format(obj.bytesize) 45 | 46 | def print_Fields(self, obj): 47 | description_string = lambda name, description: " :{}:\n {}".format(name, self.print_dispatch(description).replace("\n", "\n ")) 48 | description_strings = [description_string(name, description) for name, description in obj.items()] 49 | if obj.bytesize is None: 50 | sizestring = "?" 51 | else: 52 | sizestring = str(obj.bytesize) 53 | return "Fields(length=" + sizestring + ")\n\n" + "\n\n".join(description_strings) 54 | 55 | def print_List(self, obj): 56 | return "List\n\n - " +\ 57 | "\n\n - ".join([self.print_dispatch(d).replace("\n", "\n ") 58 | for d in obj.descriptions]) 59 | 60 | def print_MatchedLoop(self, obj): 61 | return "MatchedLoop\n\n " + self.print_dispatch(obj.description).replace("\n", "\n ") 62 | 63 | def print_KeyLoop(self, obj): 64 | return "KeyLoop(key=\"{}\"):\n\n ".format(obj.key) +\ 65 | self.print_dispatch(obj.description).replace("\n", "\n ") 66 | 67 | def print_Options(self, obj): 68 | return "#. " + "\n\n#. ".join(self.print_dispatch(d).replace("\n", "\n ") for d in obj.descriptions) 69 | -------------------------------------------------------------------------------- /ubx/descriptions/mga_ini.py: -------------------------------------------------------------------------------- 1 | from ..message_class import * 2 | from ..message_id import * 3 | from ..payload import * 4 | from ..message import * 5 | 6 | 7 | payload_description_pos_xyz = Fields( 8 | ("type", U1), 9 | ("version", U1), 10 | ("reserved1", 2*U1), 11 | ("ecefX", I4), 12 | ("ecefY", I4), 13 | ("ecefZ", I4), 14 | ("posAcc", U4) 15 | ) 16 | 17 | payload_description_pos_llh = Fields( 18 | ("type", U1), 19 | ("version", U1), 20 | ("reserved1", 2*U1), 21 | ("lat", I4), 22 | ("lon", I4), 23 | ("alt", I4), 24 | ("posAcc", U4) 25 | ) 26 | 27 | ref = Bitfield(1, entries=[ 28 | BitfieldEntry("source", slice(0, 4)), 29 | BitfieldEntry("fall", 4), 30 | BitfieldEntry("last", 5) 31 | ]) 32 | 33 | payload_description_time_utc = Fields( 34 | ("type", U1), 35 | ("version", U1), 36 | ("ref", ref), 37 | ("leapSecs", I1), 38 | ("year", U2), 39 | ("month", U1), 40 | ("day", U1), 41 | ("hour", U1), 42 | ("minute", U1), 43 | ("second", U1), 44 | ("reserved1", U1), 45 | ("ns", U4), 46 | ("tAccS", U2), 47 | ("reserved2", 2*U1), 48 | ("tAccNs", U4), 49 | ) 50 | 51 | payload_description_time_gps = Fields( 52 | ("type", U1), 53 | ("version", U1), 54 | ("ref", ref), 55 | ("gnssId", U1), 56 | ("reserved1", 2*U1), 57 | ("week", U2), 58 | ("tow", U4), 59 | ("ns", U4), 60 | ("tAccS", U2), 61 | ("reserved2", 2*U1), 62 | ("tAccNs", U4) 63 | ) 64 | 65 | payload_description_clkd = Fields( 66 | ("type", U1), 67 | ("version", U1), 68 | ("reserved1", 2*U1), 69 | ("clkD", I4), 70 | ("clkDAcc", U4) 71 | ) 72 | 73 | flags = Bitfield(1, entries=[ 74 | BitfieldEntry("source", slice(0, 4)), 75 | BitfieldEntry("fall", 4) 76 | ]) 77 | 78 | payload_description_freq = Fields( 79 | ("type", U1), 80 | ("version", U1), 81 | ("reserved1", 2*U1), 82 | ("flags", flags), 83 | ("freq", I4), 84 | ("freqAcc", U4) 85 | ) 86 | 87 | payload_description_eop = Fields( 88 | ("type", U1), 89 | ("version", U1), 90 | ("reserved1", 2*U1), 91 | ("d2kRef", U2), 92 | ("d2kMax", U2), 93 | ("xpP0", I4), 94 | ("xpP1", I4), 95 | ("ypP0", I4), 96 | ("ypP1", I4), 97 | ("dUT1", I4), 98 | ("ddUT1", I4), 99 | ("reserved2", 40*U1) 100 | ) 101 | 102 | description = MessageDescription( 103 | message_class=MGA, 104 | message_id=MessageId("INI", b"\x40"), 105 | payload_description=Options( 106 | payload_description_pos_xyz, 107 | payload_description_pos_llh, 108 | payload_description_time_utc, 109 | payload_description_time_gps, 110 | payload_description_clkd, 111 | payload_description_freq, 112 | payload_description_eop 113 | ) 114 | ) 115 | -------------------------------------------------------------------------------- /ubx/reader.py: -------------------------------------------------------------------------------- 1 | import struct 2 | 3 | from . import syncchars 4 | from . import utils 5 | from . import rawmessage 6 | from . import checksum 7 | 8 | 9 | class ReaderException(Exception): 10 | '''Ublox error class''' 11 | def __init__(self, msg): 12 | Exception.__init__(self, msg) 13 | self.message = msg 14 | 15 | 16 | class Reader: 17 | def __init__(self, read): 18 | self.read = read 19 | 20 | def read_checked(self, n): 21 | buffer = self.read(n) 22 | if len(buffer) != n: 23 | raise EOFError("Reached end of stream") 24 | return buffer 25 | 26 | def seek_syncchars(self): 27 | matched_syncchar1 = False 28 | while True: 29 | byte = self.read_checked(1) 30 | if matched_syncchar1: 31 | if byte == syncchars.CHAR2: 32 | return True 33 | else: 34 | matched_syncchar1 = False 35 | if byte == syncchars.CHAR1: 36 | matched_syncchar1 = True 37 | 38 | def check_syncchars(self): 39 | byte = self.read_checked(1) 40 | if byte != syncchars.CHAR1: 41 | raise ReaderException( 42 | "First syncchar is '0x{}' instead of '0x{}'".format( 43 | utils.byte2hexstring(byte), 44 | utils.byte2hexstring(syncchars.CHAR1))) 45 | byte = self.read_checked(1) 46 | if byte != syncchars.CHAR2: 47 | raise ReaderException( 48 | "Second syncchar is '0x{}' instead of '0x{}'".format( 49 | utils.byte2hexstring(byte), 50 | utils.byte2hexstring(syncchars.CHAR2))) 51 | 52 | def read_rawmessageparts(self, seek_syncchars=True): 53 | if seek_syncchars: 54 | self.seek_syncchars() 55 | else: 56 | self.check_syncchars() 57 | header = self.read_checked(4) 58 | byte_message_class = header[0:1] 59 | byte_message_id = header[1:2] 60 | bytes_length = header[2:4] 61 | 62 | length = struct.unpack("