reduce complexity and change default type to str

.coveragerc

@@ -1,12 +0,0 @@
-[run]
-branch = True
-include = */pyModeS/*
-omit = *tests*
-
-[report]
-exclude_lines =
-    coverage: ignore
-    raise NotImplementedError
-    if TYPE_CHECKING:
-
-ignore_errors = True

.github/workflows/pypi-publish.yml

@@ -1,29 +0,0 @@
-# This workflows will upload a Python Package using Twine when a release is created
-# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries
-
-name: PyPI Publish
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: "3.x"
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install setuptools wheel twine
-      - name: Build and publish
-        env:
-          TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
-          TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
-        run: |
-          python setup.py sdist bdist_wheel
-          twine upload dist/*

.github/workflows/run-tests.yml

@@ -1,56 +0,0 @@
-name: tests
-
-on:
-  push:
-  pull_request_target:
-  workflow_dispatch:
-
-jobs:
-  deploy:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-        python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"]
-
-    env:
-      PYTHON_VERSION: ${{ matrix.python-version }}
-
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Set up Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Install dependencies
-        run: |
-          pip install -U pip numpy cython mypy
-          pip install -U pytest codecov pytest-cov
-          pip install .
-
-      - name: Type checking
-        if: ${{ env.PYTHON_VERSION != '3.7' }}
-        run: |
-          mypy pyModeS
-
-      - name: Run tests (without Cython)
-        run: |
-          pytest tests --cov --cov-report term-missing
-
-      - name: Install with Cython
-        run: |
-          pip install -U cython
-          pip uninstall -y pymodes
-          pip install .
-
-      - name: Run tests (with Cython)
-        run: |
-          pytest tests
-
-      - name: Upload coverage to Codecov
-        if: ${{ github.event_name != 'pull_request_target' && env.PYTHON_VERSION == '3.10' }}
-        uses: codecov/codecov-action@v2
-        with:
-          env_vars: PYTHON_VERSION

.gitignore

@@ -5,6 +5,9 @@ __pycache__/
 *.py[cod]
 .pytest_cache/
 
+#cython
+.c
+
 # C extensions
 *.so
 

Makefile

@@ -8,18 +8,11 @@ ext:
 	python setup.py build_ext --inplace
 
 test:
-	make clean
+	python -m pytest
-	@echo ""
-	@echo "[Test with py_common]"
-	python -m pytest tests
-	@echo ""
-	@echo "[Test with c_common]"
-	python setup.py build_ext --inplace
-	python -m pytest tests
 
 clean:
-	find pyModeS -type f -name '*.c' -delete
+	find pyModeS/decoder -type f -name '*.c' -delete
-	find pyModeS -type f -name '*.so' -delete
+	find pyModeS/decoder -type f -name '*.so' -delete
 	find . | grep -E "(__pycache__|\.pyc|\.pyo$$)" | xargs rm -rf
 	rm -rf *.egg-info
 	rm -rf .pytest_cache

README.rst

@@ -1,42 +1,6 @@
 The Python ADS-B/Mode-S Decoder
 ===============================
 
-PyModeS is a Python library designed to decode Mode-S (including ADS-B) messages. It can be imported to your python project or used as a standalone tool to view and save live traffic data.
-
-This is a project created by Junzi Sun, who works at `TU Delft <https://www.tudelft.nl/en/>`_, `Aerospace Engineering Faculty <https://www.tudelft.nl/en/ae/>`_, `CNS/ATM research group <http://cs.lr.tudelft.nl/atm/>`_. It is supported by many `contributors <https://github.com/junzis/pyModeS/graphs/contributors>`_ from different institutions.
-
-Introduction
-------------
-
-pyModeS supports the decoding of following types of messages:
-
-- DF4 / DF20: Altitude code
-- DF5 / DF21: Identity code (squawk code)
-
-- DF17 / DF18: Automatic Dependent Surveillance-Broadcast (ADS-B)
-
-  - TC=1-4  / BDS 0,8: Aircraft identification and category
-  - TC=5-8  / BDS 0,6: Surface position
-  - TC=9-18 / BDS 0,5: Airborne position
-  - TC=19   / BDS 0,9: Airborne velocity
-  - TC=28   / BDS 6,1: Airborne status [to be implemented]
-  - TC=29   / BDS 6,2: Target state and status information [to be implemented]
-  - TC=31   / BDS 6,5: Aircraft operational status [to be implemented]
-
-- DF20 / DF21: Mode-S Comm-B messages
-
-  - BDS 1,0: Data link capability report
-  - BDS 1,7: Common usage GICB capability report
-  - BDS 2,0: Aircraft identification
-  - BDS 3,0: ACAS active resolution advisory
-  - BDS 4,0: Selected vertical intention
-  - BDS 4,4: Meteorological routine air report (experimental)
-  - BDS 4,5: Meteorological hazard report (experimental)
-  - BDS 5,0: Track and turn report
-  - BDS 6,0: Heading and speed report
-
-
-
 If you find this project useful for your research, please considering cite this tool as::
 
   @article{sun2019pymodes,
@@ -50,6 +14,40 @@ If you find this project useful for your research, please considering cite this
 
 
 
+Introduction
+---------------------
+PyModeS is a Python library designed to decode Mode-S (including ADS-B) message. It can be imported to your python project or be used as a standalone tool to view and save live traffic data.
+
+Messages with following Downlink Formats (DF) are supported:
+
+**DF17 / DF18: Automatic Dependent Surveillance-Broadcast (ADS-B)**
+
+- TC=1-4  / BDS 0,8: Aircraft identification and category
+- TC=5-8  / BDS 0,6: Surface position
+- TC=9-18 / BDS 0,5: Airborne position
+- TC=19   / BDS 0,9: Airborne velocity
+- TC=28   / BDS 6,1: Airborne status [to be implemented]
+- TC=29   / BDS 6,2: Target state and status information [to be implemented]
+- TC=31   / BDS 6,5: Aircraft operational status [to be implemented]
+
+
+**DF20 / DF21: Mode-S Comm-B replies**
+
+- BDS 1,0: Data link capability report
+- BDS 1,7: Common usage GICB capability report
+- BDS 2,0: Aircraft identification
+- BDS 3,0: ACAS active resolution advisory
+- BDS 4,0: Selected vertical intention
+- BDS 4,4: Meteorological routine air report (experimental)
+- BDS 4,5: Meteorological hazard report (experimental)
+- BDS 5,0: Track and turn report
+- BDS 6,0: Heading and speed report
+
+
+**DF4 / DF20: Altitude code**
+
+**DF5 / DF21: Identity code (squawk code)**
+
 
 Resources
 -----------
@@ -57,50 +55,26 @@ Check out and contribute to this open-source project at:
 https://github.com/junzis/pyModeS
 
 Detailed manual on Mode-S decoding is published at:
-https://mode-s.org/decode
+https://mode-s.org/decode.
 
 The API documentation of pyModeS is at:
-https://mode-s.org/api
+http://pymodes.readthedocs.io
 
 
 
-Basic installation
+Install
--------------------
+-------
 
 Installation examples::
 
   # stable version
   pip install pyModeS
 
-  # conda (compiled) version
-  conda install -c conda-forge pymodes
-
   # development version
   pip install git+https://github.com/junzis/pyModeS
 
 
-Dependencies ``numpy``, and ``pyzmq`` are installed automatically during previous installations processes. 
+Dependencies ``numpy``, ``pyzmq`` and ``pyrtlsdr`` are installed automatically during previous installations processes.
-
-If you need to connect pyModeS to a RTL-SDR receiver, ``pyrtlsdr`` need to be installed manually::
-
-  pip install pyrtlsdr
-
-
-Advanced installation (using c modules)
-------------------------------------------
-
-If you want to make use of the (faster) c module, install ``pyModeS`` as follows::
-
-  # conda (compiled) version
-  conda install -c conda-forge pymodes
-
-  # stable version (to be compiled on your side)
-  pip install pyModeS[fast]
-
-  # development version
-  git clone https://github.com/junzis/pyModeS
-  cd pyModeS
-  pip install .[fast]
 
 
 View live traffic (modeslive)
@@ -126,7 +100,7 @@ General usage::
 Live with RTL-SDR
 *******************
 
-If you have an RTL-SDR receiver connected to your computer, you can use the ``rtlsdr`` source switch (require ``pyrtlsdr`` package), with command::
+If you have an RTL-SDR receiver plugged to the computer, you can connect it with ``rtlsdr`` source switch, shown as follows::
 
   $ modeslive --source rtlsdr
 
@@ -167,7 +141,7 @@ Common functions
   pms.hex2bin(str)      # Convert hexadecimal string to binary string
   pms.bin2int(str)      # Convert binary string to integer
   pms.hex2int(str)      # Convert hexadecimal string to integer
-  pms.gray2int(str)     # Convert grey code to integer
+  pms.gray2int(str)     # Convert grey code to interger
 
 
 Core functions for ADS-B decoding
@@ -181,7 +155,7 @@ Core functions for ADS-B decoding
   # Typecode 1-4
   pms.adsb.callsign(msg)
 
-  # Typecode 5-8 (surface), 9-18 (airborne, barometric height), and 20-22 (airborne, GNSS height)
+  # Typecode 5-8 (surface), 9-18 (airborne, barometric height), and 9-18 (airborne, GNSS height)
   pms.adsb.position(msg_even, msg_odd, t_even, t_odd, lat_ref=None, lon_ref=None)
   pms.adsb.airborne_position(msg_even, msg_odd, t_even, t_odd)
   pms.adsb.surface_position(msg_even, msg_odd, t_even, t_odd, lat_ref, lon_ref)
@@ -275,20 +249,8 @@ Mode-S Enhanced Surveillance (EHS)
   pms.commb.vr60ins(msg)    # Inertial vertical speed (ft/min)
 
 
-Meteorological reports [Experimental]
+Meteorological routine air report (MRAR) [Experimental]
-**************************************
+********************************************************
-
-To identify BDS 4,4 and 4,5 codes, you must set ``mrar`` argument to ``True`` in the ``infer()`` function:
-
-.. code:: python
-
-  pms.bds.infer(msg. mrar=True) 
-
-Once the correct MRAR and MHR messages are identified, decode them as follows:
-
-
-Meteorological routine air report (MRAR)
-+++++++++++++++++++++++++++++++++++++++++
 
 .. code:: python
 
@@ -299,8 +261,8 @@ Meteorological routine air report (MRAR)
   pms.commb.hum44(msg)      # Humidity (%)
 
 
-Meteorological hazard air report (MHR)
+Meteorological hazard air report (MHR) [Experimental]
-+++++++++++++++++++++++++++++++++++++++++
+*******************************************************
 
 .. code:: python
 

doc/Makefile

@@ -17,5 +17,5 @@ help:
 # "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
 %: Makefile
 	rm -f source/pyModeS*.rst source/modules.rst
-	sphinx-apidoc -f -e -M -o source/ ../pyModeS  ../pyModeS/decoder/ehs.py ../pyModeS/decoder/els.py  ../pyModeS/streamer ../pyModeS/extra
+	sphinx-apidoc -f -e -M -o source/ ../pyModeS
 	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

doc/source/_templates/layout.html

@@ -1,17 +0,0 @@
-{% extends "!layout.html" %}
-
-{% block footer %}
-{{ super() }}
-
-<!-- Global site tag (gtag.js) - Google Analytics -->
-<script async src="https://www.googletagmanager.com/gtag/js?id=UA-74700456-1"></script>
-<script>
-  window.dataLayer = window.dataLayer || [];
-  function gtag(){dataLayer.push(arguments);}
-  gtag('js', new Date());
-
-  gtag('config', 'UA-74700456-1');
-</script>
-
-
-{% endblock %}

doc/source/conf.py

@@ -14,20 +14,19 @@
 #
 import os
 import sys
-
+sys.path.insert(0, os.path.abspath('../..'))
-sys.path.insert(0, os.path.abspath("../.."))
 
 
 # -- Project information -----------------------------------------------------
 
-project = "pyModeS"
+project = 'pyModeS'
-copyright = "2019, Junzi Sun"
+copyright = '2019, Junzi Sun'
-author = "Junzi Sun"
+author = 'Junzi Sun'
 
 # The short X.Y version
-version = ""
+version = ''
 # The full version, including alpha/beta/rc tags
-release = ""
+release = ''
 
 
 # -- General configuration ---------------------------------------------------
@@ -40,24 +39,26 @@ release = ""
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
 extensions = [
-    "sphinx.ext.autodoc",
+    'sphinx.ext.autodoc',
-    "sphinx.ext.mathjax",
+    'sphinx.ext.todo',
-    "sphinx.ext.viewcode",
+    'sphinx.ext.coverage',
-    "sphinx.ext.githubpages",
+    'sphinx.ext.mathjax',
-    "sphinx.ext.napoleon",
+    'sphinx.ext.viewcode',
+    'sphinx.ext.githubpages',
+    'sphinx.ext.napoleon',
 ]
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ["_templates"]
+# templates_path = ['']
 
 # The suffix(es) of source filenames.
 # You can specify multiple suffix as a list of string:
 #
 # source_suffix = ['.rst', '.md']
-source_suffix = ".rst"
+source_suffix = '.rst'
 
 # The master toctree document.
-master_doc = "index"
+master_doc = 'index'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -81,10 +82,6 @@ pygments_style = None
 # a list of builtin themes.
 #
 # html_theme = 'alabaster'
-html_theme = "neo_rtd_theme"
-import sphinx_theme
-
-html_theme_path = [sphinx_theme.get_html_theme_path()]
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
@@ -111,7 +108,7 @@ html_theme_path = [sphinx_theme.get_html_theme_path()]
 # -- Options for HTMLHelp output ---------------------------------------------
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = "pyModeSdoc"
+htmlhelp_basename = 'pyModeSdoc'
 
 
 # -- Options for LaTeX output ------------------------------------------------
@@ -120,12 +117,15 @@ latex_elements = {
     # The paper size ('letterpaper' or 'a4paper').
     #
     # 'papersize': 'letterpaper',
+
     # The font size ('10pt', '11pt' or '12pt').
     #
     # 'pointsize': '10pt',
+
     # Additional stuff for the LaTeX preamble.
     #
     # 'preamble': '',
+
     # Latex figure (float) alignment
     #
     # 'figure_align': 'htbp',
@@ -135,7 +135,8 @@ latex_elements = {
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
-    (master_doc, "pyModeS.tex", "pyModeS Documentation", "Junzi Sun", "manual")
+    (master_doc, 'pyModeS.tex', 'pyModeS Documentation',
+     'Junzi Sun', 'manual'),
 ]
 
 
@@ -143,7 +144,10 @@ latex_documents = [
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
-man_pages = [(master_doc, "pymodes", "pyModeS Documentation", [author], 1)]
+man_pages = [
+    (master_doc, 'pymodes', 'pyModeS Documentation',
+     [author], 1)
+]
 
 
 # -- Options for Texinfo output ----------------------------------------------
@@ -152,15 +156,9 @@ man_pages = [(master_doc, "pymodes", "pyModeS Documentation", [author], 1)]
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    (
+    (master_doc, 'pyModeS', 'pyModeS Documentation',
-        master_doc,
+     author, 'pyModeS', 'One line description of project.',
-        "pyModeS",
+     'Miscellaneous'),
-        "pyModeS Documentation",
-        author,
-        "pyModeS",
-        "One line description of project.",
-        "Miscellaneous",
-    )
 ]
 
 
@@ -179,7 +177,7 @@ epub_title = project
 # epub_uid = ''
 
 # A list of files that should not be packed into the epub file.
-epub_exclude_files = ["search.html"]
+epub_exclude_files = ['search.html']
 
 
 # -- Extension configuration -------------------------------------------------

doc/source/index.rst

@@ -9,49 +9,11 @@ Welcome to pyModeS documentation!
 The source code can be found at: https://github.com/junzis/pyModeS
 
 .. toctree::
-  :caption: Core modules
+   :maxdepth: 3
-  :maxdepth: 2
-
-  pyModeS.decoder.adsb
-  pyModeS.decoder.commb
-
-
-.. toctree::
-  :caption: ADS-B messages
-  :maxdepth: 2
-
-  pyModeS.decoder.bds.bds05
-  pyModeS.decoder.bds.bds06
-  pyModeS.decoder.bds.bds08
-  pyModeS.decoder.bds.bds09
-
-
-.. toctree::
-  :caption: ELS - elementary surveillance
-  :maxdepth: 2
-
-  pyModeS.decoder.bds.bds10
-  pyModeS.decoder.bds.bds17
-  pyModeS.decoder.bds.bds20
-  pyModeS.decoder.bds.bds30
-
-
-.. toctree::
-  :caption: EHS - enhanced surveillance
-  :maxdepth: 2
-
-  pyModeS.decoder.bds.bds40
-  pyModeS.decoder.bds.bds50
-  pyModeS.decoder.bds.bds60
-
-
-.. toctree::
-  :caption: MRAR / MHR
-  :maxdepth: 2
-
-  pyModeS.decoder.bds.bds44
-  pyModeS.decoder.bds.bds45
 
+   pyModeS.decoder
+   pyModeS.streamer
+   pyModeS.extra
 
 
 ----

doc/source/make.bat

@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=.
+set BUILDDIR=_build
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+
+:end
+popd

doc/source/pyModeS.c_common.rst

@@ -1,7 +0,0 @@
-pyModeS.c\_common module
-========================
-
-.. automodule:: pyModeS.c_common
-   :members:
-   :undoc-members:
-   :show-inheritance:

doc/source/pyModeS.common.rst

@@ -1,7 +0,0 @@
-pyModeS.common module
-=====================
-
-.. automodule:: pyModeS.common
-   :members:
-   :undoc-members:
-   :show-inheritance:

doc/source/pyModeS.decoder.acas.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.acas module
 ===========================
 
 .. automodule:: pyModeS.decoder.acas
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.adsb.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.adsb module
 ===========================
 
 .. automodule:: pyModeS.decoder.adsb
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.allcall.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.allcall module
 ==============================
 
 .. automodule:: pyModeS.decoder.allcall
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.bds.bds05.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.bds.bds05 module
 ================================
 
 .. automodule:: pyModeS.decoder.bds.bds05
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.bds.bds06.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.bds.bds06 module
 ================================
 
 .. automodule:: pyModeS.decoder.bds.bds06
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.bds.bds08.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.bds.bds08 module
 ================================
 
 .. automodule:: pyModeS.decoder.bds.bds08
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.bds.bds09.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.bds.bds09 module
 ================================
 
 .. automodule:: pyModeS.decoder.bds.bds09
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.bds.bds10.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.bds.bds10 module
 ================================
 
 .. automodule:: pyModeS.decoder.bds.bds10
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.bds.bds17.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.bds.bds17 module
 ================================
 
 .. automodule:: pyModeS.decoder.bds.bds17
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.bds.bds20.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.bds.bds20 module
 ================================
 
 .. automodule:: pyModeS.decoder.bds.bds20
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.bds.bds30.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.bds.bds30 module
 ================================
 
 .. automodule:: pyModeS.decoder.bds.bds30
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.bds.bds40.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.bds.bds40 module
 ================================
 
 .. automodule:: pyModeS.decoder.bds.bds40
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.bds.bds44.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.bds.bds44 module
 ================================
 
 .. automodule:: pyModeS.decoder.bds.bds44
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.bds.bds45.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.bds.bds45 module
 ================================
 
 .. automodule:: pyModeS.decoder.bds.bds45
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.bds.bds50.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.bds.bds50 module
 ================================
 
 .. automodule:: pyModeS.decoder.bds.bds50
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.bds.bds53.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.bds.bds53 module
 ================================
 
 .. automodule:: pyModeS.decoder.bds.bds53
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.bds.bds60.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.bds.bds60 module
 ================================
 
 .. automodule:: pyModeS.decoder.bds.bds60
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.bds.rst

@@ -2,15 +2,14 @@ pyModeS.decoder.bds package
 ===========================
 
 .. automodule:: pyModeS.decoder.bds
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:
 
 Submodules
 ----------
 
 .. toctree::
-   :maxdepth: 4
 
    pyModeS.decoder.bds.bds05
    pyModeS.decoder.bds.bds06
@@ -26,3 +25,4 @@ Submodules
    pyModeS.decoder.bds.bds50
    pyModeS.decoder.bds.bds53
    pyModeS.decoder.bds.bds60
+

doc/source/pyModeS.decoder.commb.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.commb module
 ============================
 
 .. automodule:: pyModeS.decoder.commb
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.common.rst

@@ -0,0 +1,7 @@
+pyModeS.decoder.common module
+=============================
+
+.. automodule:: pyModeS.decoder.common
+    :members:
+    :undoc-members:
+    :show-inheritance:

doc/source/pyModeS.decoder.ehs.rst

@@ -0,0 +1,7 @@
+pyModeS.decoder.ehs module
+==========================
+
+.. automodule:: pyModeS.decoder.ehs
+    :members:
+    :undoc-members:
+    :show-inheritance:

doc/source/pyModeS.decoder.els.rst

@@ -0,0 +1,7 @@
+pyModeS.decoder.els module
+==========================
+
+.. automodule:: pyModeS.decoder.els
+    :members:
+    :undoc-members:
+    :show-inheritance:

doc/source/pyModeS.decoder.rst

@@ -2,28 +2,29 @@ pyModeS.decoder package
 =======================
 
 .. automodule:: pyModeS.decoder
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:
 
 Subpackages
 -----------
 
 .. toctree::
-   :maxdepth: 4
 
-   pyModeS.decoder.bds
+    pyModeS.decoder.bds
 
 Submodules
 ----------
 
 .. toctree::
-   :maxdepth: 4
 
    pyModeS.decoder.acas
    pyModeS.decoder.adsb
    pyModeS.decoder.allcall
    pyModeS.decoder.commb
+   pyModeS.decoder.common
+   pyModeS.decoder.ehs
+   pyModeS.decoder.els
    pyModeS.decoder.surv
    pyModeS.decoder.uncertainty
-   pyModeS.decoder.uplink
+

doc/source/pyModeS.decoder.surv.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.surv module
 ===========================
 
 .. automodule:: pyModeS.decoder.surv
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.uncertainty.rst

@@ -2,6 +2,6 @@ pyModeS.decoder.uncertainty module
 ==================================
 
 .. automodule:: pyModeS.decoder.uncertainty
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:

doc/source/pyModeS.decoder.uplink.rst

@@ -1,7 +0,0 @@
-pyModeS.decoder.uplink module
-=============================
-
-.. automodule:: pyModeS.decoder.uplink
-   :members:
-   :undoc-members:
-   :show-inheritance:

doc/source/pyModeS.extra.aero.rst

@@ -0,0 +1,7 @@
+pyModeS.extra.aero module
+=========================
+
+.. automodule:: pyModeS.extra.aero
+    :members:
+    :undoc-members:
+    :show-inheritance:

doc/source/pyModeS.extra.rst

@@ -0,0 +1,16 @@
+pyModeS.extra package
+=====================
+
+.. automodule:: pyModeS.extra
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+Submodules
+----------
+
+.. toctree::
+
+   pyModeS.extra.aero
+   pyModeS.extra.tcpclient
+

doc/source/pyModeS.extra.tcpclient.rst

@@ -0,0 +1,7 @@
+pyModeS.extra.tcpclient module
+==============================
+
+.. automodule:: pyModeS.extra.tcpclient
+    :members:
+    :undoc-members:
+    :show-inheritance:

doc/source/pyModeS.rst

@@ -2,23 +2,16 @@ pyModeS package
 ===============
 
 .. automodule:: pyModeS
-   :members:
+    :members:
-   :undoc-members:
+    :undoc-members:
-   :show-inheritance:
+    :show-inheritance:
 
 Subpackages
 -----------
 
 .. toctree::
-   :maxdepth: 4
 
-   pyModeS.decoder
+    pyModeS.decoder
+    pyModeS.extra
+    pyModeS.streamer
 
-Submodules
-----------
-
-.. toctree::
-   :maxdepth: 4
-
-   pyModeS.c_common
-   pyModeS.common

doc/source/pyModeS.streamer.rst

@@ -0,0 +1,16 @@
+pyModeS.streamer package
+========================
+
+.. automodule:: pyModeS.streamer
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+Submodules
+----------
+
+.. toctree::
+
+   pyModeS.streamer.screen
+   pyModeS.streamer.stream
+

doc/source/pyModeS.streamer.screen.rst

@@ -0,0 +1,7 @@
+pyModeS.streamer.screen module
+==============================
+
+.. automodule:: pyModeS.streamer.screen
+    :members:
+    :undoc-members:
+    :show-inheritance:

doc/source/pyModeS.streamer.stream.rst

@@ -0,0 +1,7 @@
+pyModeS.streamer.stream module
+==============================
+
+.. automodule:: pyModeS.streamer.stream
+    :members:
+    :undoc-members:
+    :show-inheritance:

pyModeS/__init__.py

@@ -1,36 +1,22 @@
+from __future__ import absolute_import, print_function, division
+
 import os
 import warnings
 
 try:
-    from . import c_common as common
+    from .decoder import c_common as common
-    from .c_common import *
+    from .decoder.c_common import *
-except Exception:
+except:
-    from . import py_common as common  # type: ignore
+    from .decoder import common
-    from .py_common import *  # type: ignore
+    from .decoder.common import *
 
 from .decoder import tell
 from .decoder import adsb
-from .decoder import acas
 from .decoder import commb
-from .decoder import allcall
-from .decoder import surv
 from .decoder import bds
 from .extra import aero
 from .extra import tcpclient
 
-__all__ = [
-    "common",
-    "tell",
-    "adsb",
-    "commb",
-    "allcall",
-    "surv",
-    "bds",
-    "aero",
-    "tcpclient",
-]
-
-
 warnings.simplefilter("once", DeprecationWarning)
 
 dirpath = os.path.dirname(os.path.realpath(__file__))

pyModeS/c_common.pyi

@@ -1,18 +0,0 @@
-def hex2bin(hexstr: str) -> str: ...
-def bin2int(binstr: str) -> int: ...
-def hex2int(hexstr: str) -> int: ...
-def bin2hex(binstr: str) -> str: ...
-def df(msg: str) -> int: ...
-def crc(msg: str, encode: bool = False) -> int: ...
-def floor(x: float) -> float: ...
-def icao(msg: str) -> str: ...
-def is_icao_assigned(icao: str) -> bool: ...
-def typecode(msg: str) -> int: ...
-def cprNL(lat: float) -> int: ...
-def idcode(msg: str) -> str: ...
-def squawk(binstr: str) -> str: ...
-def altcode(msg: str) -> int: ...
-def altitude(binstr: str) -> int: ...
-def data(msg: str) -> str: ...
-def allzeros(msg: str) -> bool: ...
-def wrongstatus(data: str, sb: int, msb: int, lsb: int) -> bool: ...

pyModeS/common.pyi

@@ -1,22 +0,0 @@
-from typing import Optional
-
-def hex2bin(hexstr: str) -> str: ...
-def bin2int(binstr: str) -> int: ...
-def hex2int(hexstr: str) -> int: ...
-def bin2hex(binstr: str) -> str: ...
-def df(msg: str) -> int: ...
-def crc(msg: str, encode: bool = False) -> int: ...
-def floor(x: float) -> float: ...
-def icao(msg: str) -> Optional[str]: ...
-def is_icao_assigned(icao: str) -> bool: ...
-def typecode(msg: str) -> Optional[int]: ...
-def cprNL(lat: float) -> int: ...
-def idcode(msg: str) -> str: ...
-def squawk(binstr: str) -> str: ...
-def altcode(msg: str) -> Optional[int]: ...
-def altitude(binstr: str) -> Optional[int]: ...
-def gray2alt(binstr: str) -> Optional[int]: ...
-def gray2int(binstr: str) -> int: ...
-def data(msg: str) -> str: ...
-def allzeros(msg: str) -> bool: ...
-def wrongstatus(data: str, sb: int, msb: int, lsb: int) -> bool: ...

pyModeS/decoder/__init__.py

@@ -1,8 +1,11 @@
-def tell(msg: str) -> None:
+from __future__ import absolute_import, print_function, division
-    from .. import common, adsb, commb, bds
 
+from pyModeS.decoder import adsb, commb, common, bds
+
+
+def tell(msg):
     def _print(label, value, unit=None):
-        print("%28s: " % label, end="")
+        print("%20s: " % label, end="")
         print("%s " % value, end="")
         if unit:
             print(unit)
@@ -17,21 +20,16 @@ def tell(msg: str) -> None:
     _print("Downlink Format", df)
 
     if df == 17:
-        _print("Protocol", "Mode-S Extended Squitter (ADS-B)")
+        _print("Protocal", "Mode-S Extended Squitter (ADS-B)")
 
         tc = common.typecode(msg)
-
-        if tc is None:
-            _print("ERROR", "Unknown typecode")
-            return
-
         if 1 <= tc <= 4:  # callsign
             callsign = adsb.callsign(msg)
-            _print("Type", "Identification and category")
+            _print("Type", "Identitification and category")
             _print("Callsign:", callsign)
 
         if 5 <= tc <= 8:  # surface position
-            _print("Type", "Surface position")
+            _print("Type", "Surface postition")
             oe = adsb.oe_flag(msg)
             msgbin = common.hex2bin(msg)
             cprlat = common.bin2int(msgbin[54:71]) / 131072.0
@@ -57,14 +55,12 @@ def tell(msg: str) -> None:
 
         if tc == 19:
             _print("Type", "Airborne velocity")
-            velocity = adsb.velocity(msg)
+            spd, trk, vr, t = adsb.velocity(msg)
-            if velocity is not None:
+            types = {"GS": "Ground speed", "TAS": "True airspeed"}
-                spd, trk, vr, t = velocity
+            _print("Speed", spd, "knots")
-                types = {"GS": "Ground speed", "TAS": "True airspeed"}
+            _print("Track", trk, "degrees")
-                _print("Speed", spd, "knots")
+            _print("Vertical rate", vr, "feet/minute")
-                _print("Track", trk, "degrees")
+            _print("Type", types[t])
-                _print("Vertical rate", vr, "feet/minute")
-                _print("Type", types[t])
 
         if 20 <= tc <= 22:  # airborne position
             _print("Type", "Airborne position (with GNSS altitude)")
@@ -78,100 +74,12 @@ def tell(msg: str) -> None:
             _print("CPR Longitude", cprlon)
             _print("Altitude", alt, "feet")
 
-        if tc == 29:  # target state and status
-            _print("Type", "Target State and Status")
-            subtype = common.bin2int((common.hex2bin(msg)[32:])[5:7])
-            _print("Subtype", subtype)
-            tcas_operational = adsb.tcas_operational(msg)
-            types_29 = {0: "Not Engaged", 1: "Engaged"}
-            tcas_operational_types = {0: "Not Operational", 1: "Operational"}
-            if subtype == 0:
-                emergency_types = {
-                    0: "No emergency",
-                    1: "General emergency",
-                    2: "Lifeguard/medical emergency",
-                    3: "Minimum fuel",
-                    4: "No communications",
-                    5: "Unlawful interference",
-                    6: "Downed aircraft",
-                    7: "Reserved",
-                }
-                vertical_horizontal_types = {
-                    1: "Acquiring mode",
-                    2: "Capturing/Maintaining mode",
-                }
-                tcas_ra_types = {0: "Not active", 1: "Active"}
-                alt, alt_source, alt_ref = adsb.target_altitude(msg)
-                angle, angle_type, angle_source = adsb.target_angle(msg)
-                vertical_mode = adsb.vertical_mode(msg)
-                horizontal_mode = adsb.horizontal_mode(msg)
-                tcas_ra = adsb.tcas_ra(msg)
-                emergency_status = adsb.emergency_status(msg)
-                _print("Target altitude", alt, "feet")
-                _print("Altitude source", alt_source)
-                _print("Altitude reference", alt_ref)
-                _print("Angle", angle, "°")
-                _print("Angle Type", angle_type)
-                _print("Angle Source", angle_source)
-                if vertical_mode is not None:
-                    _print(
-                        "Vertical mode",
-                        vertical_horizontal_types[vertical_mode],
-                    )
-                if horizontal_mode is not None:
-                    _print(
-                        "Horizontal mode",
-                        vertical_horizontal_types[horizontal_mode],
-                    )
-                _print(
-                    "TCAS/ACAS",
-                    tcas_operational_types[tcas_operational]
-                    if tcas_operational
-                    else None,
-                )
-                _print("TCAS/ACAS RA", tcas_ra_types[tcas_ra])
-                _print("Emergency status", emergency_types[emergency_status])
-            else:
-                alt, alt_source = adsb.selected_altitude(msg)  # type: ignore
-                baro = adsb.baro_pressure_setting(msg)
-                hdg = adsb.selected_heading(msg)
-                autopilot = adsb.autopilot(msg)
-                vnav = adsb.vnav_mode(msg)
-                alt_hold = adsb.altitude_hold_mode(msg)
-                app = adsb.approach_mode(msg)
-                lnav = adsb.lnav_mode(msg)
-                _print("Selected altitude", alt, "feet")
-                _print("Altitude source", alt_source)
-                _print(
-                    "Barometric pressure setting",
-                    baro,
-                    "" if baro is None else "millibars",
-                )
-                _print("Selected Heading", hdg, "°")
-                if not (common.bin2int((common.hex2bin(msg)[32:])[46]) == 0):
-                    _print(
-                        "Autopilot", types_29[autopilot] if autopilot else None
-                    )
-                    _print("VNAV mode", types_29[vnav] if vnav else None)
-                    _print(
-                        "Altitude hold mode",
-                        types_29[alt_hold] if alt_hold else None,
-                    )
-                    _print("Approach mode", types_29[app] if app else None)
-                    _print(
-                        "TCAS/ACAS",
-                        tcas_operational_types[tcas_operational]
-                        if tcas_operational
-                        else None,
-                    )
-                    _print("LNAV mode", types_29[lnav] if lnav else None)
-
     if df == 20:
-        _print("Protocol", "Mode-S Comm-B altitude reply")
+        _print("Protocal", "Mode-S Comm-B altitude reply")
         _print("Altitude", common.altcode(msg), "feet")
 
     if df == 21:
-        _print("Protocol", "Mode-S Comm-B identity reply")
+        _print("Protocal", "Mode-S Comm-B identity reply")
         _print("Squawk code", common.idcode(msg))
 
     if df == 20 or df == 21:
@@ -189,7 +97,7 @@ def tell(msg: str) -> None:
         }
 
         BDS = bds.infer(msg, mrar=True)
-        if BDS is not None and BDS in labels.keys():
+        if BDS in labels.keys():
             _print("BDS", "%s (%s)" % (BDS, labels[BDS]))
         else:
             _print("BDS", BDS)

pyModeS/decoder/acas.py

@@ -1,158 +1,8 @@
 """
 Decoding Air-Air Surveillance (ACAS) DF=0/16
+
+[To be implemented]
 """
 
-from __future__ import annotations
+from __future__ import absolute_import, print_function, division
-
+from pyModeS.decoder import common
-from .. import common
-import warnings
-
-warnings.simplefilter("always", UserWarning)
-
-
-def isACAS(msg: str) -> bool:
-    """Check if the message is an ACAS coordination message.
-
-    :param msg: 28 hexdigits string
-    :return: if VDS is 3,1
-    """
-    mv = common.hex2bin(common.data(msg))
-
-    vds = mv[0:8]
-    if vds == "00110000":
-        return True
-    else:
-        return False
-
-
-def rac(msg: str) -> None | str:
-    """Resolution Advisory Complement.
-
-    :param msg: 28 hexdigits string
-    :return: RACs
-    """
-    if not isACAS(msg):
-        warnings.warn("Not an ACAS coordination message.")
-        return None
-
-    RAC = []
-
-    mv = common.hex2bin(common.data(msg))
-
-    if mv[22] == "1":
-        RAC.append("do not pass below")
-
-    if mv[23] == "1":
-        RAC.append("do not pass above")
-
-    if mv[24] == "1":
-        RAC.append("do not pass left")
-
-    if mv[25] == "1":
-        RAC.append("do not pass right")
-
-    return "; ".join(RAC)
-
-
-def rat(msg: str) -> None | int:
-    """RA terminated indicator
-
-    Mode S transponder is still required to report RA 18 seconds after
-    it is terminated by ACAS. Hence, the RAT filed is used.
-
-    :param msg: 28 hexdigits string
-    :return: if RA has been terminated
-    """
-    if not isACAS(msg):
-        warnings.warn("Not an ACAS coordination message.")
-        return None
-
-    mv = common.hex2bin(common.data(msg))
-    mte = int(mv[26])
-    return mte
-
-
-def mte(msg: str) -> None | int:
-    """Multiple threat encounter.
-
-    :param msg: 28 hexdigits string
-    :return: if there are multiple threats
-    """
-    if not isACAS(msg):
-        warnings.warn("Not an ACAS coordination message.")
-        return None
-
-    mv = common.hex2bin(common.data(msg))
-    mte = int(mv[27])
-    return mte
-
-
-def ara(msg: str) -> None | str:
-    """Decode active resolution advisory.
-
-    :param msg: 28 bytes hexadecimal message string
-    :return: RA charactristics
-    """
-    if not isACAS(msg):
-        warnings.warn("Not an ACAS coordination message.")
-        return None
-    mv = common.hex2bin(common.data(msg))
-
-    mte = int(mv[27])
-
-    ara_b1 = int(mv[8])
-    ara_b2 = int(mv[9])
-    ara_b3 = int(mv[10])
-    ara_b4 = int(mv[11])
-    ara_b5 = int(mv[12])
-    ara_b6 = int(mv[14])
-    ara_b7 = int(mv[15])
-    # ACAS III are bits 15-22
-
-    RA = []
-
-    if ara_b1 == 1:
-        if ara_b2:
-            RA.append("corrective")
-        else:
-            RA.append("preventive")
-
-        if ara_b3:
-            RA.append("downward sense")
-        else:
-            RA.append("upward sense")
-
-        if ara_b4:
-            RA.append("increased rate")
-
-        if ara_b5:
-            RA.append("sense reversal")
-
-        if ara_b6:
-            RA.append("altitude crossing")
-
-        if ara_b7:
-            RA.append("positive")
-        else:
-            RA.append("vertical speed limit")
-
-    if ara_b1 == 0 and mte == 1:
-        if ara_b2:
-            RA.append("requires a correction in the upward sense")
-
-        if ara_b3:
-            RA.append("requires a positive climb")
-
-        if ara_b4:
-            RA.append("requires a correction in downward sense")
-
-        if ara_b5:
-            RA.append("requires a positive descent")
-
-        if ara_b6:
-            RA.append("requires a crossing")
-
-        if ara_b7:
-            RA.append("requires a sense reversal")
-
-    return "; ".join(RA)

pyModeS/decoder/adsb.py

@@ -1,150 +1,73 @@
-"""ADS-B module.
+"""ADS-B Wrapper.
 
-The ADS-B module also imports functions from the following modules:
+The ADS-B wrapper also imports functions from the following modules:
 
-- bds05: ``airborne_position()``, ``airborne_position_with_ref()``,
+- pyModeS.decoder.bds.bds05
-  ``altitude()``
+    Functions: ``airborne_position``, ``airborne_position_with_ref``, ``altitude``
-- bds06: ``surface_position()``, ``surface_position_with_ref()``,
+- pyModeS.decoder.bds.bds06
-  ``surface_velocity()``
+    Functions: ``surface_position``, ``surface_position_with_ref``, ``surface_velocity``
-- bds08: ``category()``, ``callsign()``
+- pyModeS.decoder.bds.bds08
-- bds09: ``airborne_velocity()``, ``altitude_diff()``
+    Functions: ``category``, ``callsign``
+- pyModeS.decoder.bds.bds09
+    Functions: ``airborne_velocity``, ``altitude_diff``
 
 """
 
-from __future__ import annotations
+from __future__ import absolute_import, print_function, division
-from datetime import datetime
 
-from .. import common
+import pyModeS as pms
-from . import uncertainty
+from pyModeS.decoder import common
-from .bds.bds05 import airborne_position, airborne_position_with_ref
+from pyModeS.decoder import uncertainty
-from .bds.bds05 import altitude as altitude05
+
-from .bds.bds06 import (
+# from pyModeS.decoder.bds import bds05, bds06, bds09
+from pyModeS.decoder.bds.bds05 import (
+    airborne_position,
+    airborne_position_with_ref,
+    altitude as altitude05,
+)
+from pyModeS.decoder.bds.bds06 import (
     surface_position,
     surface_position_with_ref,
     surface_velocity,
 )
-from .bds.bds08 import callsign, category
+from pyModeS.decoder.bds.bds08 import category, callsign
-from .bds.bds09 import airborne_velocity, altitude_diff
+from pyModeS.decoder.bds.bds09 import airborne_velocity, altitude_diff
-from .bds.bds61_st1 import emergency_squawk, emergency_state, is_emergency
-from .bds.bds62 import (
-    altitude_hold_mode,
-    approach_mode,
-    autopilot,
-    baro_pressure_setting,
-    emergency_status,
-    horizontal_mode,
-    lnav_mode,
-    selected_altitude,
-    selected_heading,
-    target_altitude,
-    target_angle,
-    tcas_operational,
-    tcas_ra,
-    vertical_mode,
-    vnav_mode,
-)
-
-__all__ = [
-    "airborne_position",
-    "airborne_position_with_ref",
-    "altitude05",
-    "surface_position",
-    "surface_position_with_ref",
-    "surface_velocity",
-    "callsign",
-    "category",
-    "airborne_velocity",
-    "altitude_diff",
-    "emergency_squawk",
-    "emergency_state",
-    "is_emergency",
-    "df",
-    "icao",
-    "typecode",
-    "position",
-    "position_with_ref",
-    "altitude",
-    "velocity",
-    "speed_heading",
-    "oe_flag",
-    "version",
-    "nuc_p",
-    "nuc_v",
-    "nic_v1",
-    "nic_v2",
-    "nic_s",
-    "nic_a_c",
-    "nic_b",
-    "nac_p",
-    "nac_v",
-    "sil",
-    "selected_altitude",
-    "target_altitude",
-    "vertical_mode",
-    "horizontal_mode",
-    "selected_heading",
-    "target_angle",
-    "baro_pressure_setting",
-    "autopilot",
-    "vnav_mode",
-    "altitude_hold_mode",
-    "approach_mode",
-    "lnav_mode",
-    "tcas_operational",
-    "tcas_ra",
-    "emergency_status",
-]
 
 
-def df(msg: str) -> int:
+def df(msg):
     return common.df(msg)
 
 
-def icao(msg: str) -> None | str:
+def icao(msg):
     return common.icao(msg)
 
 
-def typecode(msg: str) -> None | int:
+def typecode(msg):
     return common.typecode(msg)
 
 
-def position(
+def position(msg0, msg1, t0, t1, lat_ref=None, lon_ref=None):
-    msg0: str,
+    """Decode position from a pair of even and odd position message
-    msg1: str,
+    (works with both airborne and surface position messages)
-    t0: int | datetime,
-    t1: int | datetime,
-    lat_ref: None | float = None,
-    lon_ref: None | float = None,
-) -> None | tuple[float, float]:
-    """Decode surface or airborne position from a pair of even and odd
-    position messages.
-
-    Note, that to decode surface position using the position message pair,
-    the reference position has to be provided.
 
     Args:
-        msg0 (string): even message (28 hexdigits)
+        msg0 (string): even message (28 bytes hexadecimal string)
-        msg1 (string): odd message (28 hexdigits)
+        msg1 (string): odd message (28 bytes hexadecimal string)
         t0 (int): timestamps for the even message
         t1 (int): timestamps for the odd message
-        lat_ref (float): latitude of reference position
-        lon_ref (float): longitude of reference position
 
     Returns:
         (float, float): (latitude, longitude) of the aircraft
-
     """
     tc0 = typecode(msg0)
     tc1 = typecode(msg1)
 
-    if tc0 is None or tc1 is None:
-        raise RuntimeError("Incorrect or inconsistent message types")
-
     if 5 <= tc0 <= 8 and 5 <= tc1 <= 8:
-        if lat_ref is None or lon_ref is None:
+        if (not lat_ref) or (not lon_ref):
             raise RuntimeError(
-                "Surface position encountered, a reference position"
+                "Surface position encountered, a reference \
-                " lat/lon required. Location of receiver can be used."
+                               position lat/lon required. Location of \
+                               receiver can be used."
             )
         else:
             return surface_position(msg0, msg1, t0, t1, lat_ref, lon_ref)
@@ -158,20 +81,19 @@ def position(
         return airborne_position(msg0, msg1, t0, t1)
 
     else:
-        raise RuntimeError("Incorrect or inconsistent message types")
+        raise RuntimeError("incorrect or inconsistant message types")
 
 
-def position_with_ref(msg: str, lat_ref: float, lon_ref: float) -> tuple[float, float]:
+def position_with_ref(msg, lat_ref, lon_ref):
-    """Decode position with only one message.
+    """Decode position with only one message,
-
+    knowing reference nearby location, such as previously
-    A reference position is required, which can be previously
+    calculated location, ground station, or airport location, etc.
-    calculated location, ground station, or airport location.
+    Works with both airborne and surface position messages.
-    The function works with both airborne and surface position messages.
+    The reference position shall be with in 180NM (airborne) or 45NM (surface)
-    The reference position shall be within 180NM (airborne) or 45NM (surface)
     of the true position.
 
     Args:
-        msg (str): even message (28 hexdigits)
+        msg (string): even message (28 bytes hexadecimal string)
         lat_ref: previous known latitude
         lon_ref: previous known longitude
 
@@ -181,9 +103,6 @@ def position_with_ref(msg: str, lat_ref: float, lon_ref: float) -> tuple[float,
 
     tc = typecode(msg)
 
-    if tc is None:
-        raise RuntimeError("incorrect or inconsistent message types")
-
     if 5 <= tc <= 8:
         return surface_position_with_ref(msg, lat_ref, lon_ref)
 
@@ -191,22 +110,22 @@ def position_with_ref(msg: str, lat_ref: float, lon_ref: float) -> tuple[float,
         return airborne_position_with_ref(msg, lat_ref, lon_ref)
 
     else:
-        raise RuntimeError("incorrect or inconsistent message types")
+        raise RuntimeError("incorrect or inconsistant message types")
 
 
-def altitude(msg: str) -> None | float:
+def altitude(msg):
-    """Decode aircraft altitude.
+    """Decode aircraft altitude
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (string): 28 bytes hexadecimal message string
 
     Returns:
         int: altitude in feet
-
     """
+
     tc = typecode(msg)
 
-    if tc is None or tc < 5 or tc == 19 or tc > 22:
+    if tc < 5 or tc == 19 or tc > 22:
         raise RuntimeError("%s: Not a position message" % msg)
 
     elif tc >= 5 and tc <= 8:
@@ -218,67 +137,61 @@ def altitude(msg: str) -> None | float:
         return altitude05(msg)
 
 
-def velocity(
+def velocity(msg, rtn_sources=False):
-    msg: str, source: bool = False
-) -> None | tuple[None | float, None | float, None | int, str]:
     """Calculate the speed, heading, and vertical rate
-       (handles both airborne or surface message).
+    (handles both airborne or surface message)
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (string): 28 bytes hexadecimal message string
-        source (boolean): Include direction and vertical rate sources in return.
+        rtn_source (boolean): If the function will return
-            Default to False.
+            the sources for direction of travel and vertical
-            If set to True, the function will return six value instead of four.
+            rate. This will change the return value from a four
+            element array to a six element array.
 
     Returns:
-        int, float, int, string, [string], [string]:
+        (int, float, int, string, string, string): speed (kt),
-            - Speed (kt)
+            ground track or heading (degree),
-            - Angle (degree), either ground track or heading
+            rate of climb/descent (ft/min), speed type
-            - Vertical rate (ft/min)
+            ('GS' for ground speed, 'AS' for airspeed),
-            - Speed type ('GS' for ground speed, 'AS' for airspeed)
+            direction source ('true_north' for ground track / true north
-            - [Optional] Direction source ('TRUE_NORTH' or 'MAGNETIC_NORTH')
+            as refrence, 'mag_north' for magnetic north as reference),
-            - [Optional] Vertical rate source ('BARO' or 'GNSS')
+            rate of climb/descent source ('Baro' for barometer, 'GNSS'
-
+            for GNSS constellation).
-        For surface messages, vertical rate and its respective sources are set
-        to None.
 
+            In the case of surface messages, None will be put in place
+            for vertical rate and its respective sources.
     """
-    tc = typecode(msg)
-    error = "incorrect or inconsistent message types, expecting 4<TC<9 or TC=19"
-    if tc is None:
-        raise RuntimeError(error)
 
-    if 5 <= tc <= 8:
+    if 5 <= typecode(msg) <= 8:
-        return surface_velocity(msg, source)
+        return surface_velocity(msg, rtn_sources)
 
-    elif tc == 19:
+    elif typecode(msg) == 19:
-        return airborne_velocity(msg, source)
+        return airborne_velocity(msg, rtn_sources)
 
     else:
-        raise RuntimeError(error)
+        raise RuntimeError(
+            "incorrect or inconsistant message types, expecting 4<TC<9 or TC=19"
+        )
 
 
-def speed_heading(msg: str) -> None | tuple[None | float, None | float]:
+def speed_heading(msg):
     """Get speed and ground track (or heading) from the velocity message
     (handles both airborne or surface message)
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (string): 28 bytes hexadecimal message string
 
     Returns:
         (int, float): speed (kt), ground track or heading (degree)
     """
-    decoded = velocity(msg)
+    spd, trk_or_hdg, rocd, tag = velocity(msg)
-    if decoded is None:
-        return None
-    spd, trk_or_hdg, rocd, tag = decoded
     return spd, trk_or_hdg
 
 
-def oe_flag(msg: str) -> int:
+def oe_flag(msg):
     """Check the odd/even flag. Bit 54, 0 for even, 1 for odd.
     Args:
-        msg (str): 28 hexdigits string
+        msg (string): 28 bytes hexadecimal message string
     Returns:
         int: 0 or 1, for even or odd frame
     """
@@ -286,11 +199,11 @@ def oe_flag(msg: str) -> int:
     return int(msgbin[53])
 
 
-def version(msg: str) -> int:
+def version(msg):
     """ADS-B Version
 
     Args:
-        msg (str): 28 hexdigits string, TC = 31
+        msg (string): 28 bytes hexadecimal message string, TC = 31
 
     Returns:
         int: version number
@@ -308,15 +221,13 @@ def version(msg: str) -> int:
     return version
 
 
-def nuc_p(msg: str) -> tuple[int, None | float, None | int, None | int]:
+def nuc_p(msg):
-    """Calculate NUCp, Navigation Uncertainty Category - Position
+    """Calculate NUCp, Navigation Uncertainty Category - Position (ADS-B version 1)
-    (ADS-B version 1)
 
     Args:
-        msg (str): 28 hexdigits string,
+        msg (string): 28 bytes hexadecimal message string,
 
     Returns:
-        int: NUCp, Navigation Uncertainty Category (position)
         int: Horizontal Protection Limit
         int: 95% Containment Radius - Horizontal (meters)
         int: 95% Containment Radius - Vertical (meters)
@@ -324,7 +235,7 @@ def nuc_p(msg: str) -> tuple[int, None | float, None | int, None | int]:
     """
     tc = typecode(msg)
 
-    if tc is None or tc < 5 or tc is None or tc > 22:
+    if typecode(msg) < 5 or typecode(msg) > 22:
         raise RuntimeError(
             "%s: Not a surface position message (5<TC<8), \
             airborne position message (8<TC<19), \
@@ -332,36 +243,27 @@ def nuc_p(msg: str) -> tuple[int, None | float, None | int, None | int]:
             % msg
         )
 
-    NUCp = uncertainty.TC_NUCp_lookup[tc]
+    try:
-    index = uncertainty.NUCp.get(NUCp, None)
+        NUCp = uncertainty.TC_NUCp_lookup[tc]
-
+        HPL = uncertainty.NUCp[NUCp]["HPL"]
-    if index is not None:
+        RCu = uncertainty.NUCp[NUCp]["RCu"]
-        HPL = index["HPL"]
+        RCv = uncertainty.NUCp[NUCp]["RCv"]
-        RCu = index["RCu"]
+    except KeyError:
-        RCv = index["RCv"]
-    else:
         HPL, RCu, RCv = uncertainty.NA, uncertainty.NA, uncertainty.NA
 
-    RCv = uncertainty.NA
+    if tc in [20, 21]:
+        RCv = uncertainty.NA
 
-    # RCv only available for GNSS height
+    return HPL, RCu, RCv
-    if tc == 20:
-        RCv = 4
-    elif tc == 21:
-        RCv = 15
-
-    return NUCp, HPL, RCu, RCv
 
 
-def nuc_v(msg: str) -> tuple[int, None | float, None | float]:
+def nuc_v(msg):
-    """Calculate NUCv, Navigation Uncertainty Category - Velocity
+    """Calculate NUCv, Navigation Uncertainty Category - Velocity (ADS-B version 1)
-    (ADS-B version 1)
 
     Args:
-        msg (str): 28 hexdigits string,
+        msg (string): 28 bytes hexadecimal message string,
 
     Returns:
-        int: NUCv, Navigation Uncertainty Category (velocity)
         int or string: 95% Horizontal Velocity Error
         int or string: 95% Vertical Velocity Error
     """
@@ -374,31 +276,28 @@ def nuc_v(msg: str) -> tuple[int, None | float, None | float]:
 
     msgbin = common.hex2bin(msg)
     NUCv = common.bin2int(msgbin[42:45])
-    index = uncertainty.NUCv.get(NUCv, None)
 
-    if index is not None:
+    try:
-        HVE = index["HVE"]
+        HVE = uncertainty.NUCv[NUCv]["HVE"]
-        VVE = index["VVE"]
+        VVE = uncertainty.NUCv[NUCv]["VVE"]
-    else:
+    except KeyError:
         HVE, VVE = uncertainty.NA, uncertainty.NA
 
-    return NUCv, HVE, VVE
+    return HVE, VVE
 
 
-def nic_v1(msg: str, NICs: int) -> tuple[int, None | float, None | float]:
+def nic_v1(msg, NICs):
     """Calculate NIC, navigation integrity category, for ADS-B version 1
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (string): 28 bytes hexadecimal message string
         NICs (int or string): NIC supplement
 
     Returns:
-        int: NIC, Navigation Integrity Category
         int or string: Horizontal Radius of Containment
         int or string: Vertical Protection Limit
     """
-    tc = typecode(msg)
+    if typecode(msg) < 5 or typecode(msg) > 22:
-    if tc is None or tc < 5 or tc > 22:
         raise RuntimeError(
             "%s: Not a surface position message (5<TC<8), \
             airborne position message (8<TC<19), \
@@ -406,37 +305,33 @@ def nic_v1(msg: str, NICs: int) -> tuple[int, None | float, None | float]:
             % msg
         )
 
+    tc = typecode(msg)
     NIC = uncertainty.TC_NICv1_lookup[tc]
 
     if isinstance(NIC, dict):
         NIC = NIC[NICs]
 
-    d_index = uncertainty.NICv1.get(NIC, None)
+    try:
-    Rc, VPL = uncertainty.NA, uncertainty.NA
+        Rc = uncertainty.NICv1[NIC][NICs]["Rc"]
+        VPL = uncertainty.NICv1[NIC][NICs]["VPL"]
+    except KeyError:
+        Rc, VPL = uncertainty.NA, uncertainty.NA
 
-    if d_index is not None:
+    return Rc, VPL
-        index = d_index.get(NICs, None)
-        if index is not None:
-            Rc = index["Rc"]
-            VPL = index["VPL"]
-
-    return NIC, Rc, VPL
 
 
-def nic_v2(msg: str, NICa: int, NICbc: int) -> tuple[int, int]:
+def nic_v2(msg, NICa, NICbc):
     """Calculate NIC, navigation integrity category, for ADS-B version 2
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (string): 28 bytes hexadecimal message string
         NICa (int or string): NIC supplement - A
-        NICbc (int or string): NIC supplement - B or C
+        NICbc (int or srting): NIC supplement - B or C
 
     Returns:
-        int: NIC, Navigation Integrity Category
         int or string: Horizontal Radius of Containment
     """
-    tc = typecode(msg)
+    if typecode(msg) < 5 or typecode(msg) > 22:
-    if tc is None or tc < 5 or tc > 22:
         raise RuntimeError(
             "%s: Not a surface position message (5<TC<8), \
             airborne position message (8<TC<19), \
@@ -444,6 +339,7 @@ def nic_v2(msg: str, NICa: int, NICbc: int) -> tuple[int, int]:
             % msg
         )
 
+    tc = typecode(msg)
     NIC = uncertainty.TC_NICv2_lookup[tc]
 
     if 20 <= tc <= 22:
@@ -459,14 +355,14 @@ def nic_v2(msg: str, NICa: int, NICbc: int) -> tuple[int, int]:
     except KeyError:
         Rc = uncertainty.NA
 
-    return NIC, Rc  # type: ignore
+    return Rc
 
 
-def nic_s(msg: str) -> int:
+def nic_s(msg):
     """Obtain NIC supplement bit, TC=31 message
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (string): 28 bytes hexadecimal message string
 
     Returns:
         int: NICs number (0 or 1)
@@ -484,11 +380,11 @@ def nic_s(msg: str) -> int:
     return nic_s
 
 
-def nic_a_c(msg: str) -> tuple[int, int]:
+def nic_a_c(msg):
     """Obtain NICa/c, navigation integrity category supplements a and c
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (string): 28 bytes hexadecimal message string
 
     Returns:
         (int, int): NICa and NICc number (0 or 1)
@@ -507,18 +403,18 @@ def nic_a_c(msg: str) -> tuple[int, int]:
     return nic_a, nic_c
 
 
-def nic_b(msg: str) -> int:
+def nic_b(msg):
     """Obtain NICb, navigation integrity category supplement-b
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (string): 28 bytes hexadecimal message string
 
     Returns:
         int: NICb number (0 or 1)
     """
     tc = typecode(msg)
 
-    if tc is None or tc < 9 or tc > 18:
+    if tc < 9 or tc > 18:
         raise RuntimeError(
             "%s: Not a airborne position message, expecting 8<TC<19" % msg
         )
@@ -529,18 +425,15 @@ def nic_b(msg: str) -> int:
     return nic_b
 
 
-def nac_p(msg: str) -> tuple[int, int | None, int | None]:
+def nac_p(msg):
     """Calculate NACp, Navigation Accuracy Category - Position
 
     Args:
-        msg (str): 28 hexdigits string, TC = 29 or 31
+        msg (string): 28 bytes hexadecimal message string, TC = 29 or 31
 
     Returns:
-        int: NACp, Navigation Accuracy Category (position)
+        int or string: 95% horizontal accuracy bounds, Estimated Position Uncertainty
-        int or string: 95% horizontal accuracy bounds,
+        int or string: 95% vertical accuracy bounds, Vertical Estimated Position Uncertainty
-            Estimated Position Uncertainty
-        int or string: 95% vertical accuracy bounds,
-            Vertical Estimated Position Uncertainty
     """
     tc = typecode(msg)
 
@@ -564,21 +457,18 @@ def nac_p(msg: str) -> tuple[int, int | None, int | None]:
     except KeyError:
         EPU, VEPU = uncertainty.NA, uncertainty.NA
 
-    return NACp, EPU, VEPU
+    return EPU, VEPU
 
 
-def nac_v(msg: str) -> tuple[int, float | None, float | None]:
+def nac_v(msg):
     """Calculate NACv, Navigation Accuracy Category - Velocity
 
     Args:
-        msg (str): 28 hexdigits string, TC = 19
+        msg (string): 28 bytes hexadecimal message string, TC = 19
 
     Returns:
-        int: NACv, Navigation Accuracy Category (velocity)
+        int or string: 95% horizontal accuracy bounds for velocity, Horizontal Figure of Merit
-        int or string: 95% horizontal accuracy bounds for velocity,
+        int or string: 95% vertical accuracy bounds for velocity, Vertical Figure of Merit
-            Horizontal Figure of Merit
-        int or string: 95% vertical accuracy bounds for velocity,
-            Vertical Figure of Merit
     """
     tc = typecode(msg)
 
@@ -596,30 +486,25 @@ def nac_v(msg: str) -> tuple[int, float | None, float | None]:
     except KeyError:
         HFOMr, VFOMr = uncertainty.NA, uncertainty.NA
 
-    return NACv, HFOMr, VFOMr
+    return HFOMr, VFOMr
 
 
-def sil(
+def sil(msg, version):
-    msg: str,
-    version: None | int,
-) -> tuple[float | None, float | None, str]:
     """Calculate SIL, Surveillance Integrity Level
 
     Args:
-        msg (str): 28 hexdigits string with TC = 29, 31
+        msg (string): 28 bytes hexadecimal message string with TC = 29, 31
 
     Returns:
-        int or string:
+        int or string: Probability of exceeding Horizontal Radius of Containment RCu
-            Probability of exceeding Horizontal Radius of Containment RCu
+        int or string: Probability of exceeding Vertical Integrity Containment Region VPL
-        int or string:
-            Probability of exceeding Vertical Integrity Containment Region VPL
         string: SIL supplement based on per "hour" or "sample", or 'unknown'
     """
     tc = typecode(msg)
 
     if tc not in [29, 31]:
         raise RuntimeError(
-            "%s: Not a target state and status message, \
+            "%s: Not a target state and status messag, \
                            or operation status message, expecting TC = 29 or 31"
             % msg
         )

pyModeS/decoder/allcall.py

@@ -1,98 +1,8 @@
 """
-Decode all-call reply messages, with downlink format 11
+Decoding all call replies DF=11
+
+[To be implemented]
 """
 
-
+from __future__ import absolute_import, print_function, division
-from __future__ import annotations
+from pyModeS.decoder import common
-from typing import Callable, TypeVar
-
-from .. import common
-
-T = TypeVar("T")
-F = Callable[[str], T]
-
-
-def _checkdf(func: F[T]) -> F[T]:
-
-    """Ensure downlink format is 11."""
-
-    def wrapper(msg: str) -> T:
-        df = common.df(msg)
-        if df != 11:
-            raise RuntimeError(
-                "Incorrect downlink format, expect 11, got {}".format(df)
-            )
-        return func(msg)
-
-    return wrapper
-
-
-@_checkdf
-def icao(msg: str) -> None | str:
-    """Decode transponder code (ICAO address).
-
-    Args:
-        msg (str): 14 hexdigits string
-    Returns:
-        string: ICAO address
-
-    """
-    return common.icao(msg)
-
-
-@_checkdf
-def interrogator(msg: str) -> str:
-    """Decode interrogator identifier code.
-
-    Args:
-        msg (str): 14 hexdigits string
-    Returns:
-        int: interrogator identifier code
-
-    """
-    # the CRC remainder contains the CL and IC field.
-    # the top three bits are CL field and last four bits are IC field.
-    remainder = common.crc(msg)
-    if remainder > 79:
-        IC = "corrupt IC"
-    elif remainder < 16:
-        IC = "II" + str(remainder)
-    else:
-        IC = "SI" + str(remainder - 16)
-    return IC
-
-
-@_checkdf
-def capability(msg: str) -> tuple[int, None | str]:
-    """Decode transponder capability.
-
-    Args:
-        msg (str): 14 hexdigits string
-    Returns:
-        int, str: transponder capability, description
-
-    """
-    msgbin = common.hex2bin(msg)
-    ca = common.bin2int(msgbin[5:8])
-
-    if ca == 0:
-        text = "level 1 transponder"
-    elif ca == 4:
-        text = "level 2 transponder, ability to set CA to 7, on ground"
-    elif ca == 5:
-        text = "level 2 transponder, ability to set CA to 7, airborne"
-    elif ca == 6:
-        text = (
-            "evel 2 transponder, ability to set CA to 7, "
-            "either airborne or ground"
-        )
-    elif ca == 7:
-        text = (
-            "Downlink Request value is 0, "
-            "or the Flight Status is 2, 3, 4 or 5, "
-            "either airborne or on the ground"
-        )
-    else:
-        text = None
-
-    return ca, text

pyModeS/decoder/bds/__init__.py

@@ -18,13 +18,16 @@
 Common functions for Mode-S decoding
 """
 
-from typing import Optional
+from __future__ import absolute_import, print_function, division
-
 import numpy as np
 
-from ... import common
+from pyModeS.extra import aero
-from ...extra import aero
+from pyModeS.decoder import common
-from . import (  # noqa: F401
+from pyModeS.decoder.bds import (
+    bds05,
+    bds06,
+    bds08,
+    bds09,
     bds10,
     bds17,
     bds20,
@@ -33,24 +36,22 @@ from . import (  # noqa: F401
     bds44,
     bds45,
     bds50,
+    bds53,
     bds60,
-    bds61_st1,
-    bds62,
 )
 
 
-def is50or60(msg: str, spd_ref: float, trk_ref: float, alt_ref: float) -> Optional[str]:
+def is50or60(msg, spd_ref, trk_ref, alt_ref):
     """Use reference ground speed and trk to determine BDS50 and DBS60.
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
         spd_ref (float): reference speed (ADS-B ground speed), kts
         trk_ref (float): reference track (ADS-B track angle), deg
         alt_ref (float): reference altitude (ADS-B altitude), ft
 
     Returns:
-        String or None: BDS version, or possible versions,
+        String or None: BDS version, or possible versions, or None if nothing matches.
-          or None if nothing matches.
 
     """
 
@@ -59,34 +60,25 @@ def is50or60(msg: str, spd_ref: float, trk_ref: float, alt_ref: float) -> Option
         vy = v * np.cos(np.radians(angle))
         return vx, vy
 
-    # message must be both BDS 50 and 60 before processing
     if not (bds50.is50(msg) and bds60.is60(msg)):
         return None
 
-    # --- assuming BDS60 ---
+    h50 = bds50.trk50(msg)
+    v50 = bds50.gs50(msg)
+
+    if h50 is None or v50 is None:
+        return "BDS50,BDS60"
+
     h60 = bds60.hdg60(msg)
     m60 = bds60.mach60(msg)
     i60 = bds60.ias60(msg)
 
-    # additional check now knowing the altitude
-    if (m60 is not None) and (i60 is not None):
-        ias_ = aero.mach2cas(m60, alt_ref * aero.ft) / aero.kts
-        if abs(i60 - ias_) > 20:
-            return "BDS50"
-
     if h60 is None or (m60 is None and i60 is None):
         return "BDS50,BDS60"
 
     m60 = np.nan if m60 is None else m60
     i60 = np.nan if i60 is None else i60
 
-    # --- assuming BDS50 ---
-    h50 = bds50.trk50(msg)
-    v50 = bds50.gs50(msg)
-
-    if h50 is None or v50 is None:
-        return "BDS50,BDS60"
-
     XY5 = vxy(v50 * aero.kts, h50)
     XY6m = vxy(aero.mach2tas(m60, alt_ref * aero.ft), h60)
     XY6i = vxy(aero.cas2tas(i60 * aero.kts, alt_ref * aero.ft), h60)
@@ -112,17 +104,15 @@ def is50or60(msg: str, spd_ref: float, trk_ref: float, alt_ref: float) -> Option
     return BDS
 
 
-def infer(msg: str, mrar: bool = False) -> Optional[str]:
+def infer(msg, mrar=False):
     """Estimate the most likely BDS code of an message.
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
-        mrar (bool): Also infer MRAR (BDS 44) and MHR (BDS 45).
+        mrar (bool): Also infer MRAR (BDS 44) and MHR (BDS 45). Defaults to False.
-          Defaults to False.
 
     Returns:
-        String or None: BDS version, or possible versions,
+        String or None: BDS version, or possible versions, or None if nothing matches.
-          or None if nothing matches.
 
     """
     df = common.df(msg)
@@ -133,11 +123,9 @@ def infer(msg: str, mrar: bool = False) -> Optional[str]:
     # For ADS-B / Mode-S extended squitter
     if df == 17:
         tc = common.typecode(msg)
-        if tc is None:
-            return None
 
         if 1 <= tc <= 4:
-            return "BDS08"  # identification and category
+            return "BDS08"  # indentification and category
         if 5 <= tc <= 8:
             return "BDS06"  # surface movement
         if 9 <= tc <= 18:

pyModeS/decoder/bds/bds05.py

@@ -1,24 +1,20 @@
 # ------------------------------------------
 #   BDS 0,5
 #   ADS-B TC=9-18
-#   Airborne position
+#   Airborn position
 # ------------------------------------------
 
-from __future__ import annotations
 
-from datetime import datetime
+from __future__ import absolute_import, print_function, division
-
+from pyModeS.decoder import common
-from ... import common
 
 
-def airborne_position(
+def airborne_position(msg0, msg1, t0, t1):
-    msg0: str, msg1: str, t0: int | datetime, t1: int | datetime
+    """Decode airborn position from a pair of even and odd position message
-) -> None | tuple[float, float]:
-    """Decode airborne position from a pair of even and odd position message
 
     Args:
-        msg0 (string): even message (28 hexdigits)
+        msg0 (string): even message (28 bytes hexadecimal string)
-        msg1 (string): odd message (28 hexdigits)
+        msg1 (string): odd message (28 bytes hexadecimal string)
         t0 (int): timestamps for the even message
         t1 (int): timestamps for the odd message
 
@@ -40,13 +36,13 @@ def airborne_position(
         raise RuntimeError("Both even and odd CPR frames are required.")
 
     # 131072 is 2^17, since CPR lat and lon are 17 bits each.
-    cprlat_even = common.bin2int(mb0[22:39]) / 131072
+    cprlat_even = common.bin2int(mb0[22:39]) / 131072.0
-    cprlon_even = common.bin2int(mb0[39:56]) / 131072
+    cprlon_even = common.bin2int(mb0[39:56]) / 131072.0
-    cprlat_odd = common.bin2int(mb1[22:39]) / 131072
+    cprlat_odd = common.bin2int(mb1[22:39]) / 131072.0
-    cprlon_odd = common.bin2int(mb1[39:56]) / 131072
+    cprlon_odd = common.bin2int(mb1[39:56]) / 131072.0
 
-    air_d_lat_even = 360 / 60
+    air_d_lat_even = 360.0 / 60
-    air_d_lat_odd = 360 / 59
+    air_d_lat_odd = 360.0 / 59
 
     # compute latitude index 'j'
     j = common.floor(59 * cprlat_even - 60 * cprlat_odd + 0.5)
@@ -65,19 +61,18 @@ def airborne_position(
         return None
 
     # compute ni, longitude index m, and longitude
-    # (people pass int+int or datetime+datetime)
+    if t0 > t1:
-    if t0 > t1:  # type: ignore
         lat = lat_even
         nl = common.cprNL(lat)
         ni = max(common.cprNL(lat) - 0, 1)
         m = common.floor(cprlon_even * (nl - 1) - cprlon_odd * nl + 0.5)
-        lon = (360 / ni) * (m % ni + cprlon_even)
+        lon = (360.0 / ni) * (m % ni + cprlon_even)
     else:
         lat = lat_odd
         nl = common.cprNL(lat)
         ni = max(common.cprNL(lat) - 1, 1)
         m = common.floor(cprlon_even * (nl - 1) - cprlon_odd * nl + 0.5)
-        lon = (360 / ni) * (m % ni + cprlon_odd)
+        lon = (360.0 / ni) * (m % ni + cprlon_odd)
 
     if lon > 180:
         lon = lon - 360
@@ -85,16 +80,14 @@ def airborne_position(
     return round(lat, 5), round(lon, 5)
 
 
-def airborne_position_with_ref(
+def airborne_position_with_ref(msg, lat_ref, lon_ref):
-    msg: str, lat_ref: float, lon_ref: float
-) -> tuple[float, float]:
     """Decode airborne position with only one message,
     knowing reference nearby location, such as previously calculated location,
     ground station, or airport location, etc. The reference position shall
-    be within 180NM of the true position.
+    be with in 180NM of the true position.
 
     Args:
-        msg (str): even message (28 hexdigits)
+        msg (string): even message (28 bytes hexadecimal string)
         lat_ref: previous known latitude
         lon_ref: previous known longitude
 
@@ -104,11 +97,11 @@ def airborne_position_with_ref(
 
     mb = common.hex2bin(msg)[32:]
 
-    cprlat = common.bin2int(mb[22:39]) / 131072
+    cprlat = common.bin2int(mb[22:39]) / 131072.0
-    cprlon = common.bin2int(mb[39:56]) / 131072
+    cprlon = common.bin2int(mb[39:56]) / 131072.0
 
     i = int(mb[21])
-    d_lat = 360 / 59 if i else 360 / 60
+    d_lat = 360.0 / 59 if i else 360.0 / 60
 
     j = common.floor(lat_ref / d_lat) + common.floor(
         0.5 + ((lat_ref % d_lat) / d_lat) - cprlat
@@ -119,9 +112,9 @@ def airborne_position_with_ref(
     ni = common.cprNL(lat) - i
 
     if ni > 0:
-        d_lon = 360 / ni
+        d_lon = 360.0 / ni
     else:
-        d_lon = 360
+        d_lon = 360.0
 
     m = common.floor(lon_ref / d_lon) + common.floor(
         0.5 + ((lon_ref % d_lon) / d_lon) - cprlon
@@ -132,11 +125,11 @@ def airborne_position_with_ref(
     return round(lat, 5), round(lon, 5)
 
 
-def altitude(msg: str) -> None | int:
+def altitude(msg):
     """Decode aircraft altitude
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (string): 28 bytes hexadecimal message string
 
     Returns:
         int: altitude in feet
@@ -144,14 +137,21 @@ def altitude(msg: str) -> None | int:
 
     tc = common.typecode(msg)
 
-    if tc is None or tc < 9 or tc == 19 or tc > 22:
+    if tc < 9 or tc == 19 or tc > 22:
-        raise RuntimeError("%s: Not an airborne position message" % msg)
+        raise RuntimeError("%s: Not a airborn position message" % msg)
 
     mb = common.hex2bin(msg)[32:]
-    altbin = mb[8:20]
 
     if tc < 19:
-        altcode = altbin[0:6] + "0" + altbin[6:]
+        # barometric altitude
-        return common.altitude(altcode)
+        q = mb[15]
+        if q:
+            n = common.bin2int(mb[8:15] + mb[16:20])
+            alt = n * 25 - 1000
+        else:
+            alt = None
     else:
-        return common.bin2int(altbin) * 3.28084  # type: ignore
+        # GNSS altitude, meters -> feet
+        alt = common.bin2int(mb[8:20]) * 3.28084
+
+    return alt

pyModeS/decoder/bds/bds06.py

@@ -1,31 +1,21 @@
 # ------------------------------------------
 #   BDS 0,6
 #   ADS-B TC=5-8
-#   Surface movement
+#   Surface position
 # ------------------------------------------
 
-from __future__ import annotations
+from __future__ import absolute_import, print_function, division
-
+from pyModeS.decoder import common
-from datetime import datetime
+import math
-
-from ... import common
 
 
-def surface_position(
+def surface_position(msg0, msg1, t0, t1, lat_ref, lon_ref):
-    msg0: str,
-    msg1: str,
-    t0: int | datetime,
-    t1: int | datetime,
-    lat_ref: float,
-    lon_ref: float,
-) -> None | tuple[float, float]:
-
     """Decode surface position from a pair of even and odd position message,
     the lat/lon of receiver must be provided to yield the correct solution.
 
     Args:
-        msg0 (string): even message (28 hexdigits)
+        msg0 (string): even message (28 bytes hexadecimal string)
-        msg1 (string): odd message (28 hexdigits)
+        msg1 (string): odd message (28 bytes hexadecimal string)
         t0 (int): timestamps for the even message
         t1 (int): timestamps for the odd message
         lat_ref (float): latitude of the receiver
@@ -39,13 +29,13 @@ def surface_position(
     msgbin1 = common.hex2bin(msg1)
 
     # 131072 is 2^17, since CPR lat and lon are 17 bits each.
-    cprlat_even = common.bin2int(msgbin0[54:71]) / 131072
+    cprlat_even = common.bin2int(msgbin0[54:71]) / 131072.0
-    cprlon_even = common.bin2int(msgbin0[71:88]) / 131072
+    cprlon_even = common.bin2int(msgbin0[71:88]) / 131072.0
-    cprlat_odd = common.bin2int(msgbin1[54:71]) / 131072
+    cprlat_odd = common.bin2int(msgbin1[54:71]) / 131072.0
-    cprlon_odd = common.bin2int(msgbin1[71:88]) / 131072
+    cprlon_odd = common.bin2int(msgbin1[71:88]) / 131072.0
 
-    air_d_lat_even = 90 / 60
+    air_d_lat_even = 90.0 / 60
-    air_d_lat_odd = 90 / 59
+    air_d_lat_odd = 90.0 / 59
 
     # compute latitude index 'j'
     j = common.floor(59 * cprlat_even - 60 * cprlat_odd + 0.5)
@@ -55,8 +45,8 @@ def surface_position(
     lat_odd_n = float(air_d_lat_odd * (j % 59 + cprlat_odd))
 
     # solution for north hemisphere
-    lat_even_s = lat_even_n - 90
+    lat_even_s = lat_even_n - 90.0
-    lat_odd_s = lat_odd_n - 90
+    lat_odd_s = lat_odd_n - 90.0
 
     # chose which solution corrispondes to receiver location
     lat_even = lat_even_n if lat_ref > 0 else lat_even_s
@@ -67,44 +57,41 @@ def surface_position(
         return None
 
     # compute ni, longitude index m, and longitude
-    # (people pass int+int or datetime+datetime)
+    if t0 > t1:
-    if t0 > t1:  # type: ignore
         lat = lat_even
         nl = common.cprNL(lat_even)
         ni = max(common.cprNL(lat_even) - 0, 1)
         m = common.floor(cprlon_even * (nl - 1) - cprlon_odd * nl + 0.5)
-        lon = (90 / ni) * (m % ni + cprlon_even)
+        lon = (90.0 / ni) * (m % ni + cprlon_even)
     else:
         lat = lat_odd
         nl = common.cprNL(lat_odd)
         ni = max(common.cprNL(lat_odd) - 1, 1)
         m = common.floor(cprlon_even * (nl - 1) - cprlon_odd * nl + 0.5)
-        lon = (90 / ni) * (m % ni + cprlon_odd)
+        lon = (90.0 / ni) * (m % ni + cprlon_odd)
 
     # four possible longitude solutions
-    lons = [lon, lon + 90, lon + 180, lon + 270]
+    lons = [lon, lon + 90.0, lon + 180.0, lon + 270.0]
 
     # make sure lons are between -180 and 180
-    lons = [(lon + 180) % 360 - 180 for lon in lons]
+    lons = [(l + 180) % 360 - 180 for l in lons]
 
     # the closest solution to receiver is the correct one
-    dls = [abs(lon_ref - lon) for lon in lons]
+    dls = [abs(lon_ref - l) for l in lons]
     imin = min(range(4), key=dls.__getitem__)
     lon = lons[imin]
 
     return round(lat, 5), round(lon, 5)
 
 
-def surface_position_with_ref(
+def surface_position_with_ref(msg, lat_ref, lon_ref):
-    msg: str, lat_ref: float, lon_ref: float
-) -> tuple[float, float]:
     """Decode surface position with only one message,
     knowing reference nearby location, such as previously calculated location,
     ground station, or airport location, etc. The reference position shall
-    be within 45NM of the true position.
+    be with in 45NM of the true position.
 
     Args:
-        msg (str): even message (28 hexdigits)
+        msg (string): even message (28 bytes hexadecimal string)
         lat_ref: previous known latitude
         lon_ref: previous known longitude
 
@@ -114,11 +101,11 @@ def surface_position_with_ref(
 
     mb = common.hex2bin(msg)[32:]
 
-    cprlat = common.bin2int(mb[22:39]) / 131072
+    cprlat = common.bin2int(mb[22:39]) / 131072.0
-    cprlon = common.bin2int(mb[39:56]) / 131072
+    cprlon = common.bin2int(mb[39:56]) / 131072.0
 
     i = int(mb[21])
-    d_lat = 90 / 59 if i else 90 / 60
+    d_lat = 90.0 / 59 if i else 90.0 / 60
 
     j = common.floor(lat_ref / d_lat) + common.floor(
         0.5 + ((lat_ref % d_lat) / d_lat) - cprlat
@@ -129,9 +116,9 @@ def surface_position_with_ref(
     ni = common.cprNL(lat) - i
 
     if ni > 0:
-        d_lon = 90 / ni
+        d_lon = 90.0 / ni
     else:
-        d_lon = 90
+        d_lon = 90.0
 
     m = common.floor(lon_ref / d_lon) + common.floor(
         0.5 + ((lon_ref % d_lon) / d_lon) - cprlon
@@ -142,29 +129,24 @@ def surface_position_with_ref(
     return round(lat, 5), round(lon, 5)
 
 
-def surface_velocity(
+def surface_velocity(msg, rtn_sources=False):
-    msg: str, source: bool = False
+    """Decode surface velocity from from a surface position message
-) -> tuple[None | float, float, int, str]:
-    """Decode surface velocity from a surface position message
-
     Args:
-        msg (str): 28 hexdigits string
+        msg (string): 28 bytes hexadecimal message string
-        source (boolean): Include direction and vertical rate sources in return.
+        rtn_source (boolean): If the function will return
-            Default to False.
+            the sources for direction of travel and vertical
-            If set to True, the function will return six value instead of four.
+            rate. This will change the return value from a four
+            element array to a six element array.
 
     Returns:
-        int, float, int, string, [string], [string]:
+        (int, float, int, string, string, None): speed (kt),
-            - Speed (kt)
+            ground track (degree), None for rate of climb/descend (ft/min),
-            - Angle (degree), ground track
+            and speed type ('GS' for ground speed), direction source
-            - Vertical rate, always 0
+            ('true_north' for ground track / true north as reference),
-            - Speed type ('GS' for ground speed, 'AS' for airspeed)
+            None rate of climb/descent source.
-            - [Optional] Direction source ('TRUE_NORTH')
-            - [Optional] Vertical rate source (None)
-
     """
-    tc = common.typecode(msg)
+
-    if tc is None or tc < 5 or tc > 8:
+    if common.typecode(msg) < 5 or common.typecode(msg) > 8:
         raise RuntimeError("%s: Not a surface message, expecting 5<TC<8" % msg)
 
     mb = common.hex2bin(msg)[32:]
@@ -172,28 +154,29 @@ def surface_velocity(
     # ground track
     trk_status = int(mb[12])
     if trk_status == 1:
-        trk = common.bin2int(mb[13:20]) * 360 / 128
+        trk = common.bin2int(mb[13:20]) * 360.0 / 128.0
         trk = round(trk, 1)
     else:
         trk = None
 
-    # ground movement / speed
+    # ground movment / speed
     mov = common.bin2int(mb[5:12])
 
     if mov == 0 or mov > 124:
         spd = None
     elif mov == 1:
-        spd = 0.0
+        spd = 0
     elif mov == 124:
-        spd = 175.0
+        spd = 175
     else:
-        mov_lb = [2, 9, 13, 39, 94, 109, 124]
+        movs = [2, 9, 13, 39, 94, 109, 124]
-        kts_lb: list[float] = [0.125, 1, 2, 15, 70, 100, 175]
+        kts = [0.125, 1, 2, 15, 70, 100, 175]
-        step: list[float] = [0.125, 0.25, 0.5, 1, 2, 5]
+        i = next(m[0] for m in enumerate(movs) if m[1] > mov)
-        i = next(m[0] for m in enumerate(mov_lb) if m[1] > mov)
+        step = (kts[i] - kts[i - 1]) * 1.0 / (movs[i] - movs[i - 1])
-        spd = kts_lb[i - 1] + (mov - mov_lb[i - 1]) * step[i - 1]
+        spd = kts[i - 1] + (mov - movs[i - 1]) * step
+        spd = round(spd, 2)
 
-    if source:
+    if rtn_sources:
-        return spd, trk, 0, "GS", "TRUE_NORTH", None  # type: ignore
+        return spd, trk, 0, "GS", "true_north", None
     else:
         return spd, trk, 0, "GS"

pyModeS/decoder/bds/bds08.py

@@ -1,24 +1,24 @@
 # ------------------------------------------
 #   BDS 0,8
 #   ADS-B TC=1-4
-#   Aircraft identification and category
+#   Aircraft identitification and category
 # ------------------------------------------
 
-from ... import common
+from __future__ import absolute_import, print_function, division
+from pyModeS.decoder import common
 
 
-def category(msg: str) -> int:
+def category(msg):
     """Aircraft category number
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (string): 28 bytes hexadecimal message string
 
     Returns:
         int: category number
     """
 
-    tc = common.typecode(msg)
+    if common.typecode(msg) < 1 or common.typecode(msg) > 4:
-    if tc is None or tc < 1 or tc > 4:
         raise RuntimeError("%s: Not a identification message" % msg)
 
     msgbin = common.hex2bin(msg)
@@ -26,18 +26,17 @@ def category(msg: str) -> int:
     return common.bin2int(mebin[5:8])
 
 
-def callsign(msg: str) -> str:
+def callsign(msg):
     """Aircraft callsign
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (string): 28 bytes hexadecimal message string
 
     Returns:
         string: callsign
     """
-    tc = common.typecode(msg)
 
-    if tc is None or tc < 1 or tc > 4:
+    if common.typecode(msg) < 1 or common.typecode(msg) > 4:
         raise RuntimeError("%s: Not a identification message" % msg)
 
     chars = "#ABCDEFGHIJKLMNOPQRSTUVWXYZ#####_###############0123456789######"

pyModeS/decoder/bds/bds09.py

@@ -1,41 +1,37 @@
 # ------------------------------------------
 #   BDS 0,9
 #   ADS-B TC=19
-#   Aircraft Airborne velocity
+#   Aircraft Airborn velocity
 # ------------------------------------------
 
-from __future__ import annotations
+from __future__ import absolute_import, print_function, division
-
+from pyModeS.decoder import common
 import math
 
-from ... import common
 
-
+def airborne_velocity(msg, rtn_sources=False):
-def airborne_velocity(
+    """Calculate the speed, track (or heading), and vertical rate
-    msg: str, source: bool = False
-) -> None | tuple[None | int, None | float, None | int, str]:
-    """Decode airborne velocity.
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (string): 28 bytes hexadecimal message string
-        source (boolean): Include direction and vertical rate sources in return.
+        rtn_source (boolean): If the function will return
-            Default to False.
+            the sources for direction of travel and vertical
-            If set to True, the function will return six value instead of four.
+            rate. This will change the return value from a four
+            element array to a six element array.
 
     Returns:
-        int, float, int, string, [string], [string]:
+        (int, float, int, string, string, string): speed (kt),
-            - Speed (kt)
+            ground track or heading (degree),
-            - Angle (degree), either ground track or heading
+            rate of climb/descent (ft/min), speed type
-            - Vertical rate (ft/min)
+            ('GS' for ground speed, 'AS' for airspeed),
-            - Speed type ('GS' for ground speed, 'AS' for airspeed)
+            direction source ('true_north' for ground track / true north
-            - [Optional] Direction source ('TRUE_NORTH' or 'MAGNETIC_NORTH')
+            as refrence, 'mag_north' for magnetic north as reference),
-            - [Optional] Vertical rate source ('BARO' or 'GNSS')
+            rate of climb/descent source ('Baro' for barometer, 'GNSS'
-
+            for GNSS constellation).
     """
+
     if common.typecode(msg) != 19:
-        raise RuntimeError(
+        raise RuntimeError("%s: Not a airborne velocity message, expecting TC=19" % msg)
-            "%s: Not a airborne velocity message, expecting TC=19" % msg
-        )
 
     mb = common.hex2bin(msg)[32:]
 
@@ -44,100 +40,77 @@ def airborne_velocity(
     if common.bin2int(mb[14:24]) == 0 or common.bin2int(mb[25:35]) == 0:
         return None
 
-    trk_or_hdg: None | float
-    spd: None | float
-
     if subtype in (1, 2):
+        v_ew_sign = -1 if mb[13] == "1" else 1
+        v_ew = common.bin2int(mb[14:24]) - 1  # east-west velocity
+        if subtype == 2:  # Supersonic
+            v_ew *= 4
 
-        v_ew = common.bin2int(mb[14:24])
+        v_ns_sign = -1 if mb[24] == "1" else 1
-        v_ns = common.bin2int(mb[25:35])
+        v_ns = common.bin2int(mb[25:35]) - 1  # north-south velocity
+        if subtype == 2:  # Supersonic
+            v_ns *= 4
 
-        if v_ew == 0 or v_ns == 0:
+        v_we = v_ew_sign * v_ew
-            spd = None
+        v_sn = v_ns_sign * v_ns
-            trk_or_hdg = None
-            vs = None
-        else:
-            v_ew_sign = -1 if mb[13] == "1" else 1
-            v_ew = v_ew - 1  # east-west velocity
-            if subtype == 2:  # Supersonic
-                v_ew *= 4
 
-            v_ns_sign = -1 if mb[24] == "1" else 1
+        spd = math.sqrt(v_sn * v_sn + v_we * v_we)  # unit in kts
-            v_ns = v_ns - 1  # north-south velocity
+        spd = int(spd)
-            if subtype == 2:  # Supersonic
-                v_ns *= 4
 
-            v_we = v_ew_sign * v_ew
+        trk = math.atan2(v_we, v_sn)
-            v_sn = v_ns_sign * v_ns
+        trk = math.degrees(trk)  # convert to degrees
+        trk = trk if trk >= 0 else trk + 360  # no negative val
 
-            spd = math.sqrt(v_sn * v_sn + v_we * v_we)  # unit in kts
+        tag = "GS"
-            spd = int(spd)
+        trk_or_hdg = round(trk, 2)
-
+        dir_type = "true_north"
-            trk = math.atan2(v_we, v_sn)
-            trk = math.degrees(trk)  # convert to degrees
-            trk = trk if trk >= 0 else trk + 360  # no negative val
-
-            trk_or_hdg = round(trk, 2)
-
-        spd_type = "GS"
-        dir_type = "TRUE_NORTH"
 
     else:
         if mb[13] == "0":
             hdg = None
         else:
-            hdg = common.bin2int(mb[14:24]) / 1024 * 360.0
+            hdg = common.bin2int(mb[14:24]) / 1024.0 * 360.0
             hdg = round(hdg, 2)
 
         trk_or_hdg = hdg
 
         spd = common.bin2int(mb[25:35])
         spd = None if spd == 0 else spd - 1
-        if subtype == 4 and spd is not None:  # Supersonic
+        if subtype == 4:  # Supersonic
             spd *= 4
 
         if mb[24] == "0":
-            spd_type = "IAS"
+            tag = "IAS"
         else:
-            spd_type = "TAS"
+            tag = "TAS"
 
-        dir_type = "MAGNETIC_NORTH"
+        dir_type = "mag_north"
 
-    vr_source = "GNSS" if mb[35] == "0" else "BARO"
+    vr_source = "GNSS" if mb[35] == "0" else "Baro"
     vr_sign = -1 if mb[36] == "1" else 1
     vr = common.bin2int(mb[37:46])
-    vs = None if vr == 0 else int(vr_sign * (vr - 1) * 64)
+    rocd = None if vr == 0 else int(vr_sign * (vr - 1) * 64)
 
-    if source:
+    if rtn_sources:
-        return (  # type: ignore
+        return spd, trk_or_hdg, rocd, tag, dir_type, vr_source
-            spd,
-            trk_or_hdg,
-            vs,
-            spd_type,
-            dir_type,
-            vr_source,
-        )
     else:
-        return spd, trk_or_hdg, vs, spd_type
+        return spd, trk_or_hdg, rocd, tag
 
 
-def altitude_diff(msg: str) -> None | float:
+def altitude_diff(msg):
-    """Decode the differece between GNSS and barometric altitude.
+    """Decode the differece between GNSS and barometric altitude
 
     Args:
-        msg (str): 28 hexdigits string, TC=19
+        msg (string): 28 bytes hexadecimal message string, TC=19
 
     Returns:
-        int: Altitude difference in feet. Negative value indicates GNSS altitude
+        int: Altitude difference in ft. Negative value indicates GNSS altitude
-        below barometric altitude.
+            below barometric altitude.
-
     """
     tc = common.typecode(msg)
 
-    if tc is None or tc != 19:
+    if tc != 19:
-        raise RuntimeError(
+        raise RuntimeError("%s: Not a airborne velocity message, expecting TC=19" % msg)
-            "%s: Not a airborne velocity message, expecting TC=19" % msg
-        )
 
     msgbin = common.hex2bin(msg)
     sign = -1 if int(msgbin[80]) else 1

pyModeS/decoder/bds/bds10.py

@@ -3,51 +3,51 @@
 # Data link capability report
 # ------------------------------------------
 
-
+from __future__ import absolute_import, print_function, division
-from ... import common
+from pyModeS.decoder.common import hex2bin, bin2int, data, allzeros
 
 
-def is10(msg: str) -> bool:
+def is10(msg):
     """Check if a message is likely to be BDS code 1,0
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         bool: True or False
     """
 
-    if common.allzeros(msg):
+    if allzeros(msg):
         return False
 
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     # first 8 bits must be 0x10
     if d[0:8] != "00010000":
         return False
 
     # bit 10 to 14 are reserved
-    if common.bin2int(d[9:14]) != 0:
+    if bin2int(d[9:14]) != 0:
         return False
 
-    # overlay capability conflict
+    # overlay capabilty conflict
-    if d[14] == "1" and common.bin2int(d[16:23]) < 5:
+    if d[14] == "1" and bin2int(d[16:23]) < 5:
         return False
-    if d[14] == "0" and common.bin2int(d[16:23]) > 4:
+    if d[14] == "0" and bin2int(d[16:23]) > 4:
         return False
 
     return True
 
 
-def ovc10(msg: str) -> int:
+def ovc10(msg):
     """Return the overlay control capability
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         int: Whether the transponder is OVC capable
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     return int(d[14])

pyModeS/decoder/bds/bds17.py

@@ -3,27 +3,27 @@
 #   Common usage GICB capability report
 # ------------------------------------------
 
-from typing import List
 
-from ... import common
+from __future__ import absolute_import, print_function, division
+from pyModeS.decoder.common import hex2bin, bin2int, data, allzeros
 
 
-def is17(msg: str) -> bool:
+def is17(msg):
     """Check if a message is likely to be BDS code 1,7
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         bool: True or False
     """
 
-    if common.allzeros(msg):
+    if allzeros(msg):
         return False
 
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
-    if common.bin2int(d[24:56]) != 0:
+    if bin2int(d[28:56]) != 0:
         return False
 
     caps = cap17(msg)
@@ -40,14 +40,14 @@ def is17(msg: str) -> bool:
     return True
 
 
-def cap17(msg: str) -> List[str]:
+def cap17(msg):
     """Extract capacities from BDS 1,7 message
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
-        list: list of supported BDS codes
+        list: list of suport BDS codes
     """
     allbds = [
         "05",
@@ -74,10 +74,14 @@ def cap17(msg: str) -> List[str]:
         "56",
         "5F",
         "60",
+        "NA",
+        "NA",
+        "E1",
+        "E2",
     ]
 
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
-    idx = [i for i, v in enumerate(d[:24]) if v == "1"]
+    idx = [i for i, v in enumerate(d[:28]) if v == "1"]
-    capacity = ["BDS" + allbds[i] for i in idx]
+    capacity = ["BDS" + allbds[i] for i in idx if allbds[i] is not "NA"]
 
     return capacity

pyModeS/decoder/bds/bds20.py

@@ -3,58 +3,57 @@
 # Aircraft identification
 # ------------------------------------------
 
-from ... import common
+from __future__ import absolute_import, print_function, division
+from pyModeS.decoder.common import hex2bin, bin2int, data, allzeros
 
 
-def is20(msg: str) -> bool:
+def is20(msg):
     """Check if a message is likely to be BDS code 2,0
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         bool: True or False
     """
 
-    if common.allzeros(msg):
+    if allzeros(msg):
         return False
 
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[0:8] != "00100000":
         return False
 
-    # allow empty callsign
+    cs = cs20(msg)
-    if common.bin2int(d[8:56]) == 0:
-        return True
 
-    if "#" in cs20(msg):
+    if "#" in cs:
         return False
 
     return True
 
 
-def cs20(msg: str) -> str:
+def cs20(msg):
     """Aircraft callsign
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message (BDS40) string
 
     Returns:
         string: callsign, max. 8 chars
     """
     chars = "#ABCDEFGHIJKLMNOPQRSTUVWXYZ#####_###############0123456789######"
 
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     cs = ""
-    cs += chars[common.bin2int(d[8:14])]
+    cs += chars[bin2int(d[8:14])]
-    cs += chars[common.bin2int(d[14:20])]
+    cs += chars[bin2int(d[14:20])]
-    cs += chars[common.bin2int(d[20:26])]
+    cs += chars[bin2int(d[20:26])]
-    cs += chars[common.bin2int(d[26:32])]
+    cs += chars[bin2int(d[26:32])]
-    cs += chars[common.bin2int(d[32:38])]
+    cs += chars[bin2int(d[32:38])]
-    cs += chars[common.bin2int(d[38:44])]
+    cs += chars[bin2int(d[38:44])]
-    cs += chars[common.bin2int(d[44:50])]
+    cs += chars[bin2int(d[44:50])]
-    cs += chars[common.bin2int(d[50:56])]
+    cs += chars[bin2int(d[50:56])]
 
     return cs

pyModeS/decoder/bds/bds30.py

@@ -3,23 +3,24 @@
 # ACAS active resolution advisory
 # ------------------------------------------
 
-from ... import common
+from __future__ import absolute_import, print_function, division
+from pyModeS.decoder.common import hex2bin, bin2int, data, allzeros
 
 
-def is30(msg: str) -> bool:
+def is30(msg):
-    """Check if a message is likely to be BDS code 3,0
+    """Check if a message is likely to be BDS code 2,0
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         bool: True or False
     """
 
-    if common.allzeros(msg):
+    if allzeros(msg):
         return False
 
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[0:8] != "00110000":
         return False
@@ -29,7 +30,7 @@ def is30(msg: str) -> bool:
         return False
 
     # reserved for ACAS III, in far future
-    if common.bin2int(d[15:22]) >= 48:
+    if bin2int(d[15:22]) >= 48:
         return False
 
     return True

pyModeS/decoder/bds/bds40.py

@@ -3,122 +3,119 @@
 # Selected vertical intention
 # ------------------------------------------
 
+from __future__ import absolute_import, print_function, division
 import warnings
-from typing import Optional
+from pyModeS.decoder.common import hex2bin, bin2int, data, allzeros, wrongstatus
-
-from ... import common
 
 
-def is40(msg: str) -> bool:
+def is40(msg):
     """Check if a message is likely to be BDS code 4,0
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         bool: True or False
     """
 
-    if common.allzeros(msg):
+    if allzeros(msg):
         return False
 
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     # status bit 1, 14, and 27
 
-    if common.wrongstatus(d, 1, 2, 13):
+    if wrongstatus(d, 1, 2, 13):
         return False
 
-    if common.wrongstatus(d, 14, 15, 26):
+    if wrongstatus(d, 14, 15, 26):
         return False
 
-    if common.wrongstatus(d, 27, 28, 39):
+    if wrongstatus(d, 27, 28, 39):
         return False
 
-    if common.wrongstatus(d, 48, 49, 51):
+    if wrongstatus(d, 48, 49, 51):
         return False
 
-    if common.wrongstatus(d, 54, 55, 56):
+    if wrongstatus(d, 54, 55, 56):
         return False
 
     # bits 40-47 and 52-53 shall all be zero
 
-    if common.bin2int(d[39:47]) != 0:
+    if bin2int(d[39:47]) != 0:
         return False
 
-    if common.bin2int(d[51:53]) != 0:
+    if bin2int(d[51:53]) != 0:
         return False
 
     return True
 
 
-def selalt40mcp(msg: str) -> Optional[int]:
+def selalt40mcp(msg):
     """Selected altitude, MCP/FCU
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message (BDS40) string
 
     Returns:
         int: altitude in feet
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[0] == "0":
         return None
 
-    alt = common.bin2int(d[1:13]) * 16  # ft
+    alt = bin2int(d[1:13]) * 16  # ft
     return alt
 
 
-def selalt40fms(msg: str) -> Optional[int]:
+def selalt40fms(msg):
     """Selected altitude, FMS
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message (BDS40) string
 
     Returns:
         int: altitude in feet
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[13] == "0":
         return None
 
-    alt = common.bin2int(d[14:26]) * 16  # ft
+    alt = bin2int(d[14:26]) * 16  # ft
     return alt
 
 
-def p40baro(msg: str) -> Optional[float]:
+def p40baro(msg):
     """Barometric pressure setting
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message (BDS40) string
 
     Returns:
         float: pressure in millibar
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[26] == "0":
         return None
 
-    p = common.bin2int(d[27:39]) * 0.1 + 800  # millibar
+    p = bin2int(d[27:39]) * 0.1 + 800  # millibar
     return p
 
 
-def alt40mcp(msg: str) -> Optional[int]:
+def alt40mcp(msg):
     warnings.warn(
-        """alt40mcp() has been renamed to selalt40mcp().
+        "alt40mcp() has been renamed to selalt40mcp(). It will be removed in the future.",
-        It will be removed in the future.""",
         DeprecationWarning,
     )
     return selalt40mcp(msg)
 
 
-def alt40fms(msg: str) -> Optional[int]:
+def alt40fms(msg):
     warnings.warn(
-        """alt40fms() has been renamed to selalt40fms().
+        "alt40fms() has been renamed to selalt40fms(). It will be removed in the future.",
-        It will be removed in the future.""",
         DeprecationWarning,
     )
-    return selalt40fms(msg)
+    return selalt40mcp(msg)

pyModeS/decoder/bds/bds44.py

@@ -3,43 +3,42 @@
 # Meteorological routine air report
 # ------------------------------------------
 
-from typing import Optional, Tuple
+from __future__ import absolute_import, print_function, division
-
+from pyModeS.decoder.common import hex2bin, bin2int, data, allzeros, wrongstatus
-from ... import common
 
 
-def is44(msg: str) -> bool:
+def is44(msg):
     """Check if a message is likely to be BDS code 4,4.
 
     Meteorological routine air report
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         bool: True or False
 
     """
-    if common.allzeros(msg):
+    if allzeros(msg):
         return False
 
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     # status bit 5, 35, 47, 50
-    if common.wrongstatus(d, 5, 6, 23):
+    if wrongstatus(d, 5, 6, 23):
         return False
 
-    if common.wrongstatus(d, 35, 36, 46):
+    if wrongstatus(d, 35, 36, 46):
         return False
 
-    if common.wrongstatus(d, 47, 48, 49):
+    if wrongstatus(d, 47, 48, 49):
         return False
 
-    if common.wrongstatus(d, 50, 51, 56):
+    if wrongstatus(d, 50, 51, 56):
         return False
 
     # Bits 1-4 indicate source, values > 4 reserved and should not occur
-    if common.bin2int(d[0:4]) > 4:
+    if bin2int(d[0:4]) > 4:
         return False
 
     vw, dw = wind44(msg)
@@ -53,44 +52,44 @@ def is44(msg: str) -> bool:
     return True
 
 
-def wind44(msg: str) -> Tuple[Optional[int], Optional[float]]:
+def wind44(msg):
     """Wind speed and direction.
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         (int, float): speed (kt), direction (degree)
 
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     status = int(d[4])
     if not status:
         return None, None
 
-    speed = common.bin2int(d[5:14])  # knots
+    speed = bin2int(d[5:14])  # knots
-    direction = common.bin2int(d[14:23]) * 180 / 256  # degree
+    direction = bin2int(d[14:23]) * 180.0 / 256.0  # degree
 
     return round(speed, 0), round(direction, 1)
 
 
-def temp44(msg: str) -> Tuple[float, float]:
+def temp44(msg):
     """Static air temperature.
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         float, float: temperature and alternative temperature in Celsius degree.
-            Note: Two values returns due to what seems to be an inconsistency
+            Note: Two values returns due to what seems to be an inconsistancy
             error in ICAO 9871 (2008) Appendix A-67.
 
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     sign = int(d[23])
-    value = common.bin2int(d[24:34])
+    value = bin2int(d[24:34])
 
     if sign:
         value = value - 1024
@@ -104,60 +103,60 @@ def temp44(msg: str) -> Tuple[float, float]:
     return temp, temp_alternative
 
 
-def p44(msg: str) -> Optional[int]:
+def p44(msg):
     """Static pressure.
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         int: static pressure in hPa
 
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[34] == "0":
         return None
 
-    p = common.bin2int(d[35:46])  # hPa
+    p = bin2int(d[35:46])  # hPa
 
     return p
 
 
-def hum44(msg: str) -> Optional[float]:
+def hum44(msg):
     """humidity
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         float: percentage of humidity, [0 - 100] %
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[49] == "0":
         return None
 
-    hm = common.bin2int(d[50:56]) * 100 / 64  # %
+    hm = bin2int(d[50:56]) * 100.0 / 64  # %
 
     return round(hm, 1)
 
 
-def turb44(msg: str) -> Optional[int]:
+def turb44(msg):
-    """Turbulence.
+    """Turblence.
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         int: turbulence level. 0=NIL, 1=Light, 2=Moderate, 3=Severe
 
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[46] == "0":
         return None
 
-    turb = common.bin2int(d[47:49])
+    turb = bin2int(d[47:49])
 
     return turb

pyModeS/decoder/bds/bds45.py

@@ -3,55 +3,54 @@
 # Meteorological hazard report
 # ------------------------------------------
 
-from typing import Optional
+from __future__ import absolute_import, print_function, division
-
+from pyModeS.decoder.common import hex2bin, bin2int, data, allzeros, wrongstatus
-from ... import common
 
 
-def is45(msg: str) -> bool:
+def is45(msg):
     """Check if a message is likely to be BDS code 4,5.
 
     Meteorological hazard report
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         bool: True or False
 
     """
-    if common.allzeros(msg):
+    if allzeros(msg):
         return False
 
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     # status bit 1, 4, 7, 10, 13, 16, 27, 39
-    if common.wrongstatus(d, 1, 2, 3):
+    if wrongstatus(d, 1, 2, 3):
         return False
 
-    if common.wrongstatus(d, 4, 5, 6):
+    if wrongstatus(d, 4, 5, 6):
         return False
 
-    if common.wrongstatus(d, 7, 8, 9):
+    if wrongstatus(d, 7, 8, 9):
         return False
 
-    if common.wrongstatus(d, 10, 11, 12):
+    if wrongstatus(d, 10, 11, 12):
         return False
 
-    if common.wrongstatus(d, 13, 14, 15):
+    if wrongstatus(d, 13, 14, 15):
         return False
 
-    if common.wrongstatus(d, 16, 17, 26):
+    if wrongstatus(d, 16, 17, 26):
         return False
 
-    if common.wrongstatus(d, 27, 28, 38):
+    if wrongstatus(d, 27, 28, 38):
         return False
 
-    if common.wrongstatus(d, 39, 40, 51):
+    if wrongstatus(d, 39, 40, 51):
         return False
 
     # reserved
-    if common.bin2int(d[51:56]) != 0:
+    if bin2int(d[51:56]) != 0:
         return False
 
     temp = temp45(msg)
@@ -62,110 +61,110 @@ def is45(msg: str) -> bool:
     return True
 
 
-def turb45(msg: str) -> Optional[int]:
+def turb45(msg):
     """Turbulence.
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         int: Turbulence level. 0=NIL, 1=Light, 2=Moderate, 3=Severe
 
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
     if d[0] == "0":
         return None
 
-    turb = common.bin2int(d[1:3])
+    turb = bin2int(d[1:3])
     return turb
 
 
-def ws45(msg: str) -> Optional[int]:
+def ws45(msg):
     """Wind shear.
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         int: Wind shear level. 0=NIL, 1=Light, 2=Moderate, 3=Severe
 
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
     if d[3] == "0":
         return None
 
-    ws = common.bin2int(d[4:6])
+    ws = bin2int(d[4:6])
     return ws
 
 
-def mb45(msg: str) -> Optional[int]:
+def mb45(msg):
     """Microburst.
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         int: Microburst level. 0=NIL, 1=Light, 2=Moderate, 3=Severe
 
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
     if d[6] == "0":
         return None
 
-    mb = common.bin2int(d[7:9])
+    mb = bin2int(d[7:9])
     return mb
 
 
-def ic45(msg: str) -> Optional[int]:
+def ic45(msg):
     """Icing.
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         int: Icing level. 0=NIL, 1=Light, 2=Moderate, 3=Severe
 
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
     if d[9] == "0":
         return None
 
-    ic = common.bin2int(d[10:12])
+    ic = bin2int(d[10:12])
     return ic
 
 
-def wv45(msg: str) -> Optional[int]:
+def wv45(msg):
     """Wake vortex.
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         int: Wake vortex level. 0=NIL, 1=Light, 2=Moderate, 3=Severe
 
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
     if d[12] == "0":
         return None
 
-    ws = common.bin2int(d[13:15])
+    ws = bin2int(d[13:15])
     return ws
 
 
-def temp45(msg: str) -> Optional[float]:
+def temp45(msg):
     """Static air temperature.
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         float: tmeperature in Celsius degree
 
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     sign = int(d[16])
-    value = common.bin2int(d[17:26])
+    value = bin2int(d[17:26])
 
     if sign:
         value = value - 512
@@ -176,35 +175,35 @@ def temp45(msg: str) -> Optional[float]:
     return temp
 
 
-def p45(msg: str) -> Optional[int]:
+def p45(msg):
     """Average static pressure.
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         int: static pressure in hPa
 
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
     if d[26] == "0":
         return None
-    p = common.bin2int(d[27:38])  # hPa
+    p = bin2int(d[27:38])  # hPa
     return p
 
 
-def rh45(msg: str) -> Optional[int]:
+def rh45(msg):
     """Radio height.
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         int: radio height in ft
 
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
     if d[38] == "0":
         return None
-    rh = common.bin2int(d[39:51]) * 16
+    rh = bin2int(d[39:51]) * 16
     return rh

pyModeS/decoder/bds/bds50.py

@@ -3,46 +3,45 @@
 # Track and turn report
 # ------------------------------------------
 
-from typing import Optional
+from __future__ import absolute_import, print_function, division
-
+from pyModeS.decoder.common import hex2bin, bin2int, data, allzeros, wrongstatus
-from ... import common
 
 
-def is50(msg: str) -> bool:
+def is50(msg):
     """Check if a message is likely to be BDS code 5,0
     (Track and turn report)
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         bool: True or False
     """
 
-    if common.allzeros(msg):
+    if allzeros(msg):
         return False
 
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     # status bit 1, 12, 24, 35, 46
 
-    if common.wrongstatus(d, 1, 3, 11):
+    if wrongstatus(d, 1, 3, 11):
         return False
 
-    if common.wrongstatus(d, 12, 13, 23):
+    if wrongstatus(d, 12, 13, 23):
         return False
 
-    if common.wrongstatus(d, 24, 25, 34):
+    if wrongstatus(d, 24, 25, 34):
         return False
 
-    if common.wrongstatus(d, 35, 36, 45):
+    if wrongstatus(d, 35, 36, 45):
         return False
 
-    if common.wrongstatus(d, 46, 47, 56):
+    if wrongstatus(d, 46, 47, 56):
         return False
 
     roll = roll50(msg)
-    if (roll is not None) and abs(roll) > 50:
+    if (roll is not None) and abs(roll) > 60:
         return False
 
     gs = gs50(msg)
@@ -59,52 +58,52 @@ def is50(msg: str) -> bool:
     return True
 
 
-def roll50(msg: str) -> Optional[float]:
+def roll50(msg):
     """Roll angle, BDS 5,0 message
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message (BDS50) string
 
     Returns:
         float: angle in degrees,
                negative->left wing down, positive->right wing down
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[0] == "0":
         return None
 
     sign = int(d[1])  # 1 -> left wing down
-    value = common.bin2int(d[2:11])
+    value = bin2int(d[2:11])
 
     if sign:
         value = value - 512
 
-    angle = value * 45 / 256  # degree
+    angle = value * 45.0 / 256.0  # degree
     return round(angle, 1)
 
 
-def trk50(msg: str) -> Optional[float]:
+def trk50(msg):
     """True track angle, BDS 5,0 message
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message (BDS50) string
 
     Returns:
         float: angle in degrees to true north (from 0 to 360)
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[11] == "0":
         return None
 
     sign = int(d[12])  # 1 -> west
-    value = common.bin2int(d[13:23])
+    value = bin2int(d[13:23])
 
     if sign:
         value = value - 1024
 
-    trk = value * 90 / 512.0
+    trk = value * 90.0 / 512.0
 
     # convert from [-180, 180] to [0, 360]
     if trk < 0:
@@ -113,34 +112,34 @@ def trk50(msg: str) -> Optional[float]:
     return round(trk, 3)
 
 
-def gs50(msg: str) -> Optional[float]:
+def gs50(msg):
     """Ground speed, BDS 5,0 message
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message (BDS50) string
 
     Returns:
         int: ground speed in knots
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[23] == "0":
         return None
 
-    spd = common.bin2int(d[24:34]) * 2  # kts
+    spd = bin2int(d[24:34]) * 2  # kts
     return spd
 
 
-def rtrk50(msg: str) -> Optional[float]:
+def rtrk50(msg):
     """Track angle rate, BDS 5,0 message
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message (BDS50) string
 
     Returns:
         float: angle rate in degrees/second
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[34] == "0":
         return None
@@ -149,27 +148,27 @@ def rtrk50(msg: str) -> Optional[float]:
         return None
 
     sign = int(d[35])  # 1 -> negative value, two's complement
-    value = common.bin2int(d[36:45])
+    value = bin2int(d[36:45])
     if sign:
         value = value - 512
 
-    angle = value * 8 / 256  # degree / sec
+    angle = value * 8.0 / 256.0  # degree / sec
     return round(angle, 3)
 
 
-def tas50(msg: str) -> Optional[float]:
+def tas50(msg):
     """Aircraft true airspeed, BDS 5,0 message
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message (BDS50) string
 
     Returns:
         int: true airspeed in knots
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[45] == "0":
         return None
 
-    tas = common.bin2int(d[46:56]) * 2  # kts
+    tas = bin2int(d[46:56]) * 2  # kts
     return tas

pyModeS/decoder/bds/bds53.py

@@ -3,42 +3,41 @@
 # Air-referenced state vector
 # ------------------------------------------
 
-from typing import Optional
+from __future__ import absolute_import, print_function, division
-
+from pyModeS.decoder.common import hex2bin, bin2int, data, allzeros, wrongstatus
-from ... import common
 
 
-def is53(msg: str) -> bool:
+def is53(msg):
     """Check if a message is likely to be BDS code 5,3
     (Air-referenced state vector)
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         bool: True or False
     """
 
-    if common.allzeros(msg):
+    if allzeros(msg):
         return False
 
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     # status bit 1, 13, 24, 34, 47
 
-    if common.wrongstatus(d, 1, 3, 12):
+    if wrongstatus(d, 1, 3, 12):
         return False
 
-    if common.wrongstatus(d, 13, 14, 23):
+    if wrongstatus(d, 13, 14, 23):
         return False
 
-    if common.wrongstatus(d, 24, 25, 33):
+    if wrongstatus(d, 24, 25, 33):
         return False
 
-    if common.wrongstatus(d, 34, 35, 46):
+    if wrongstatus(d, 34, 35, 46):
         return False
 
-    if common.wrongstatus(d, 47, 49, 56):
+    if wrongstatus(d, 47, 49, 56):
         return False
 
     ias = ias53(msg)
@@ -60,27 +59,27 @@ def is53(msg: str) -> bool:
     return True
 
 
-def hdg53(msg: str) -> Optional[float]:
+def hdg53(msg):
     """Magnetic heading, BDS 5,3 message
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message (BDS53) string
 
     Returns:
         float: angle in degrees to true north (from 0 to 360)
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[0] == "0":
         return None
 
     sign = int(d[1])  # 1 -> west
-    value = common.bin2int(d[2:12])
+    value = bin2int(d[2:12])
 
     if sign:
         value = value - 1024
 
-    hdg = value * 90 / 512  # degree
+    hdg = value * 90.0 / 512.0  # degree
 
     # convert from [-180, 180] to [0, 360]
     if hdg < 0:
@@ -89,76 +88,76 @@ def hdg53(msg: str) -> Optional[float]:
     return round(hdg, 3)
 
 
-def ias53(msg: str) -> Optional[float]:
+def ias53(msg):
     """Indicated airspeed, DBS 5,3 message
 
     Args:
-        msg (str): 28 hexdigits
+        msg (String): 28 bytes hexadecimal message
 
     Returns:
         int: indicated arispeed in knots
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[12] == "0":
         return None
 
-    ias = common.bin2int(d[13:23])  # knots
+    ias = bin2int(d[13:23])  # knots
     return ias
 
 
-def mach53(msg: str) -> Optional[float]:
+def mach53(msg):
     """MACH number, DBS 5,3 message
 
     Args:
-        msg (str): 28 hexdigits
+        msg (String): 28 bytes hexadecimal message
 
     Returns:
         float: MACH number
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[23] == "0":
         return None
 
-    mach = common.bin2int(d[24:33]) * 0.008
+    mach = bin2int(d[24:33]) * 0.008
     return round(mach, 3)
 
 
-def tas53(msg: str) -> Optional[float]:
+def tas53(msg):
     """Aircraft true airspeed, BDS 5,3 message
 
     Args:
-        msg (str): 28 hexdigits
+        msg (String): 28 bytes hexadecimal message
 
     Returns:
         float: true airspeed in knots
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[33] == "0":
         return None
 
-    tas = common.bin2int(d[34:46]) * 0.5  # kts
+    tas = bin2int(d[34:46]) * 0.5  # kts
     return round(tas, 1)
 
 
-def vr53(msg: str) -> Optional[int]:
+def vr53(msg):
     """Vertical rate
 
     Args:
-        msg (str): 28 hexdigits (BDS60) string
+        msg (String): 28 bytes hexadecimal message (BDS60) string
 
     Returns:
         int: vertical rate in feet/minutes
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[46] == "0":
         return None
 
     sign = int(d[47])  # 1 -> negative value, two's complement
-    value = common.bin2int(d[48:56])
+    value = bin2int(d[48:56])
 
     if value == 0 or value == 255:  # all zeros or all ones
         return 0

pyModeS/decoder/bds/bds60.py

@@ -3,42 +3,40 @@
 # Heading and speed report
 # ------------------------------------------
 
-from typing import Optional
+from __future__ import absolute_import, print_function, division
-
+from pyModeS.decoder.common import hex2bin, bin2int, data, allzeros, wrongstatus
-from ... import common
-from ...extra import aero
 
 
-def is60(msg: str) -> bool:
+def is60(msg):
     """Check if a message is likely to be BDS code 6,0
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message string
 
     Returns:
         bool: True or False
     """
 
-    if common.allzeros(msg):
+    if allzeros(msg):
         return False
 
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     # status bit 1, 13, 24, 35, 46
 
-    if common.wrongstatus(d, 1, 2, 12):
+    if wrongstatus(d, 1, 2, 12):
         return False
 
-    if common.wrongstatus(d, 13, 14, 23):
+    if wrongstatus(d, 13, 14, 23):
         return False
 
-    if common.wrongstatus(d, 24, 25, 34):
+    if wrongstatus(d, 24, 25, 34):
         return False
 
-    if common.wrongstatus(d, 35, 36, 45):
+    if wrongstatus(d, 35, 36, 45):
         return False
 
-    if common.wrongstatus(d, 46, 47, 56):
+    if wrongstatus(d, 46, 47, 56):
         return False
 
     ias = ias60(msg)
@@ -57,98 +55,90 @@ def is60(msg: str) -> bool:
     if vr_ins is not None and abs(vr_ins) > 6000:
         return False
 
-    # additional check knowing altitude
-    if (mach is not None) and (ias is not None) and (common.df(msg) == 20):
-        alt = common.altcode(msg)
-        if alt is not None:
-            ias_ = aero.mach2cas(mach, alt * aero.ft) / aero.kts
-            if abs(ias - ias_) > 20:
-                return False
-
     return True
 
 
-def hdg60(msg: str) -> Optional[float]:
+def hdg60(msg):
     """Megnetic heading of aircraft
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message (BDS60) string
 
     Returns:
         float: heading in degrees to megnetic north (from 0 to 360)
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[0] == "0":
         return None
 
     sign = int(d[1])  # 1 -> west
-    value = common.bin2int(d[2:12])
+    value = bin2int(d[2:12])
 
     if sign:
         value = value - 1024
 
-    hdg = value * 90 / 512  # degree
+    hdg = value * 90 / 512.0  # degree
 
     # convert from [-180, 180] to [0, 360]
     if hdg < 0:
         hdg = 360 + hdg
 
-    return hdg
+    return round(hdg, 3)
 
 
-def ias60(msg: str) -> Optional[float]:
+def ias60(msg):
     """Indicated airspeed
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message (BDS60) string
 
     Returns:
         int: indicated airspeed in knots
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[12] == "0":
         return None
 
-    ias = common.bin2int(d[13:23])  # kts
+    ias = bin2int(d[13:23])  # kts
     return ias
 
 
-def mach60(msg: str) -> Optional[float]:
+def mach60(msg):
     """Aircraft MACH number
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message (BDS60) string
 
     Returns:
         float: MACH number
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[23] == "0":
         return None
 
-    mach = common.bin2int(d[24:34]) * 2.048 / 512.0
+    mach = bin2int(d[24:34]) * 2.048 / 512.0
-    return mach
+    return round(mach, 3)
 
 
-def vr60baro(msg: str) -> Optional[int]:
+def vr60baro(msg):
     """Vertical rate from barometric measurement, this value may be very noisy.
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message (BDS60) string
 
     Returns:
         int: vertical rate in feet/minutes
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[34] == "0":
         return None
 
     sign = int(d[35])  # 1 -> negative value, two's complement
-    value = common.bin2int(d[36:45])
+    value = bin2int(d[36:45])
 
     if value == 0 or value == 511:  # all zeros or all ones
         return 0
@@ -159,22 +149,22 @@ def vr60baro(msg: str) -> Optional[int]:
     return roc
 
 
-def vr60ins(msg: str) -> Optional[int]:
+def vr60ins(msg):
-    """Vertical rate measurd by onbard equiments (IRS, AHRS)
+    """Vertical rate messured by onbard equiments (IRS, AHRS)
 
     Args:
-        msg (str): 28 hexdigits string
+        msg (String): 28 bytes hexadecimal message (BDS60) string
 
     Returns:
         int: vertical rate in feet/minutes
     """
-    d = common.hex2bin(common.data(msg))
+    d = hex2bin(data(msg))
 
     if d[45] == "0":
         return None
 
     sign = int(d[46])  # 1 -> negative value, two's complement
-    value = common.bin2int(d[47:56])
+    value = bin2int(d[47:56])
 
     if value == 0 or value == 511:  # all zeros or all ones
         return 0

pyModeS/decoder/bds/bds61_st1.py

@@ -1,88 +0,0 @@
-# ------------------------------------------
-#   BDS 6,1
-#   ADS-B TC=28
-#   Aircraft Airborne status
-#   (Subtype 1)
-# ------------------------------------------
-
-from ... import common
-
-
-def is_emergency(msg: str) -> bool:
-    """Check if the aircraft is reporting an emergency.
-
-    Non-emergencies are either a subtype of zero (no information) or
-    subtype of one and a value of zero (no emergency).
-    Subtype = 2 indicates an ACAS RA broadcast, look in BDS 3,0
-
-    :param msg: 28 bytes hexadecimal message string
-    :return: if the aircraft has declared an emergency
-    """
-    if common.typecode(msg) != 28:
-        raise RuntimeError(
-            "%s: Not an airborne status message, expecting TC=28" % msg
-        )
-
-    mb = common.hex2bin(msg)[32:]
-    subtype = common.bin2int(mb[5:8])
-
-    if subtype == 2:
-        raise RuntimeError("%s: Emergency message is ACAS-RA, not implemented")
-
-    emergency_state = common.bin2int(mb[8:11])
-
-    if subtype == 1 and emergency_state == 1:
-        return True
-    else:
-        return False
-
-
-def emergency_state(msg: str) -> int:
-    """Decode aircraft emergency state.
-
-    Value   Meaning
-    -----   -----------------------
-    0       No emergency
-    1       General emergency
-    2       Lifeguard/Medical
-    3       Minimum fuel
-    4       No communications
-    5       Unlawful communications
-    6-7     Reserved
-
-    :param msg: 28 bytes hexadecimal message string
-    :return: emergency state
-    """
-
-    mb = common.hex2bin(msg)[32:]
-    subtype = common.bin2int(mb[5:8])
-
-    if subtype == 2:
-        raise RuntimeError("%s: Emergency message is ACAS-RA, not implemented")
-
-    emergency_state = common.bin2int(mb[8:11])
-    return emergency_state
-
-
-def emergency_squawk(msg: str) -> str:
-    """Decode squawk code.
-
-    Emergency value 1: squawk 7700.
-    Emergency value 4: squawk 7600.
-    Emergency value 5: squawk 7500.
-
-    :param msg: 28 bytes hexadecimal message string
-    :return: aircraft squawk code
-    """
-    if common.typecode(msg) != 28:
-        raise RuntimeError(
-            "%s: Not an airborne status message, expecting TC=28" % msg
-        )
-
-    msgbin = common.hex2bin(msg)
-
-    # construct the 13 bits Mode A ID code
-    idcode = msgbin[43:56]
-
-    squawk = common.squawk(idcode)
-    return squawk

pyModeS/decoder/bds/bds61_st2.py

@@ -1,102 +0,0 @@
-# ------------------------------------------
-#   BDS 6,1
-#   ADS-B TC=28
-#   Aircraft Airborne status
-#   (Subtype 1)
-# ------------------------------------------
-
-from __future__ import annotations
-
-from ... import common
-from .. import acas
-
-
-def threat_type(msg: str) -> int:
-    """Determine the threat type indicator.
-
-    Value    Meaning
-    -----    ---------------------------------------
-    0        No identity data in TID
-    1        TID has Mode S address (ICAO)
-    2        TID has altitude, range, and bearing
-    3        Not assigned
-
-    :param msg: 28 hexdigits string
-    :return: indicator of threat type
-    """
-    mb = common.hex2bin(common.data(msg))
-    tti = common.bin2int(mb[28:30])
-    return tti
-
-
-def threat_identity(msg: str) -> str:
-    mb = common.hex2bin(common.data(msg))
-    tti = threat_type(msg)
-
-    # The ICAO of the threat is announced
-    if tti == 1:
-        return common.icao(mb[30:55])
-    else:
-        raise RuntimeError("%s: Missing threat identity (ICAO)")
-
-
-def threat_location(msg: str) -> None | tuple[int, int, int]:
-    """Get the altitude, range, and bearing of the threat.
-
-    Altitude is the Mode C altitude
-
-    :param msg: 28 hexdigits string
-    :return: tuple of the Mode C altitude, range, and bearing
-    """
-    mb = common.hex2bin(common.data(msg))
-    tti = threat_type(msg)
-
-    # Altitude, range, and bearing of threat
-    if tti == 2:
-        altitude = common.altitude(mb[31:44])
-        distance = common.bin2int(mb[44:51])
-        bearing = common.bin2int(mb[51:57])
-        return altitude, distance, bearing
-
-    return None
-
-
-def has_multiple_threats(msg: str) -> bool:
-    """Indicate if the ACAS is processing multiple threats simultaneously.
-
-    :param msg: 28 hexdigits string
-    :return: if there are multiple threats
-    """
-    return acas.mte(msg) == 1
-
-
-def active_resolution_advisories(msg: str) -> None | str:
-    """Decode active resolution advisory.
-
-    Uses ARA decoding function from ACAS module.
-
-    :param msg: 28 bytes hexadecimal message string
-    :return: RA charactristics
-    """
-    return acas.ara(msg)
-
-
-def is_ra_terminated(msg: str) -> bool:
-    """Indicate if the threat is still being generated.
-
-    Mode S transponder is still required to report RA 18 seconds after
-    it is terminated by ACAS. Hence, the RAT filed is used.
-
-    :param msg: 28 hexdigits string
-    :return: if the threat is terminated
-    """
-    return acas.rat(msg) == 1
-
-
-def ra_complement(msg: str) -> None | str:
-    """Resolution Advisory Complement.
-
-    :param msg: 28 hexdigits string
-    :return: RACs
-    """
-    return acas.rac(msg)

pyModeS/decoder/bds/bds62.py

@@ -1,553 +0,0 @@
-# ------------------------------------------
-#   BDS 6,2
-#   ADS-B TC=29
-#   Target State and Status
-# ------------------------------------------
-
-from __future__ import annotations
-
-from ... import common
-
-
-def selected_altitude(msg: str) -> tuple[None | float, str]:
-    """Decode selected altitude.
-
-    Args:
-        msg (str): 28 hexdigits string
-
-    Returns:
-        int: Selected altitude (ft)
-        string: Source ('MCP/FCU' or 'FMS')
-
-    """
-
-    if common.typecode(msg) != 29:
-        raise RuntimeError(
-            "%s: Not a target state and status message, expecting TC=29" % msg
-        )
-
-    mb = common.hex2bin(msg)[32:]
-
-    subtype = common.bin2int(mb[5:7])
-
-    if subtype == 0:
-        raise RuntimeError(
-            "%s: ADS-B version 1 target state and status message does not"
-            " contain selected altitude, use target altitude instead" % msg
-        )
-
-    alt = common.bin2int(mb[9:20])
-    if alt == 0:
-        return None, "N/A"
-    alt = (alt - 1) * 32
-    alt_source = "MCP/FCU" if int(mb[8]) == 0 else "FMS"
-
-    return alt, alt_source
-
-
-def target_altitude(msg: str) -> tuple[None | int, str, str]:
-    """Decode target altitude.
-
-    Args:
-        msg (str): 28 hexdigits string
-
-    Returns:
-        int: Target altitude (ft)
-        string: Source ('MCP/FCU', 'Holding mode' or 'FMS/RNAV')
-        string: Altitude reference, either pressure altitude or barometric
-           corrected altitude ('FL' or 'MSL')
-
-    """
-
-    if common.typecode(msg) != 29:
-        raise RuntimeError(
-            "%s: Not a target state and status message, expecting TC=29" % msg
-        )
-
-    mb = common.hex2bin(msg)[32:]
-
-    subtype = common.bin2int(mb[5:7])
-
-    if subtype == 1:
-        raise RuntimeError(
-            "%s: ADS-B version 2 target state and status message does not"
-            " contain target altitude, use selected altitude instead" % msg
-        )
-
-    alt_avail = common.bin2int(mb[7:9])
-    if alt_avail == 0:
-        return None, "N/A", ""
-    elif alt_avail == 1:
-        alt_source = "MCP/FCU"
-    elif alt_avail == 2:
-        alt_source = "Holding mode"
-    else:
-        alt_source = "FMS/RNAV"
-
-    alt_ref = "FL" if int(mb[9]) == 0 else "MSL"
-
-    alt = -1000 + common.bin2int(mb[15:25]) * 100
-
-    return alt, alt_source, alt_ref
-
-
-def vertical_mode(msg: str) -> None | int:
-    """Decode vertical mode.
-
-    Value   Meaning
-    -----   -----------------------
-    1       "Acquiring" mode
-    2       "Capturing" or "Maintaining" mode
-    3       Reserved
-
-    Args:
-        msg (str): 28 hexdigits string
-
-    Returns:
-        int: Vertical mode
-
-    """
-
-    if common.typecode(msg) != 29:
-        raise RuntimeError(
-            "%s: Not a target state and status message, expecting TC=29" % msg
-        )
-
-    mb = common.hex2bin(msg)[32:]
-
-    subtype = common.bin2int(mb[5:7])
-
-    if subtype == 1:
-        raise RuntimeError(
-            "%s: ADS-B version 2 target state and status message does not"
-            " contain vertical mode, use vnav mode instead" % msg
-        )
-
-    vertical_mode = common.bin2int(mb[13:15])
-    if vertical_mode == 0:
-        return None
-
-    return vertical_mode
-
-
-def horizontal_mode(msg: str) -> None | int:
-    """Decode horizontal mode.
-
-    Value   Meaning
-    -----   -----------------------
-    1       "Acquiring" mode
-    2       "Capturing" or "Maintaining" mode
-    3       Reserved
-
-    Args:
-        msg (str): 28 hexdigits string
-
-    Returns:
-        int: Horizontal mode
-
-    """
-
-    if common.typecode(msg) != 29:
-        raise RuntimeError(
-            "%s: Not a target state and status message, expecting TC=29" % msg
-        )
-
-    mb = common.hex2bin(msg)[32:]
-
-    subtype = common.bin2int(mb[5:7])
-
-    if subtype == 1:
-        raise RuntimeError(
-            "%s: ADS-B version 2 target state and status message does not "
-            "contain horizontal mode, use lnav mode instead" % msg
-        )
-
-    horizontal_mode = common.bin2int(mb[25:27])
-    if horizontal_mode == 0:
-        return None
-
-    return horizontal_mode
-
-
-def selected_heading(msg: str) -> None | float:
-    """Decode selected heading.
-
-    Args:
-        msg (str): 28 bytes hexadecimal message string
-
-    Returns:
-        float: Selected heading (degree)
-
-    """
-
-    if common.typecode(msg) != 29:
-        raise RuntimeError(
-            "%s: Not a target state and status message, expecting TC=29" % msg
-        )
-
-    mb = common.hex2bin(msg)[32:]
-
-    subtype = common.bin2int(mb[5:7])
-
-    if subtype == 0:
-        raise RuntimeError(
-            "%s: ADS-B version 1 target state and status message does not "
-            "contain selected heading, use target angle instead" % msg
-        )
-
-    if int(mb[29]) == 0:
-        return None
-    else:
-        hdg_sign = int(mb[30])
-        hdg = (hdg_sign + 1) * common.bin2int(mb[31:39]) * (180 / 256)
-        hdg = round(hdg, 2)
-
-    return hdg
-
-
-def target_angle(msg: str) -> tuple[None | int, str, str]:
-    """Decode target heading/track angle.
-
-    Args:
-        msg (str): 28 bytes hexadecimal message string
-
-    Returns:
-        int: Target angle (degree)
-        string: Angle type ('Heading' or 'Track')
-        string: Source ('MCP/FCU', 'Autopilot Mode' or 'FMS/RNAV')
-
-    """
-
-    if common.typecode(msg) != 29:
-        raise RuntimeError(
-            "%s: Not a target state and status message, expecting TC=29" % msg
-        )
-
-    mb = common.hex2bin(msg)[32:]
-
-    subtype = common.bin2int(mb[5:7])
-
-    if subtype == 1:
-        raise RuntimeError(
-            "%s: ADS-B version 2 target state and status message does not "
-            "contain target angle, use selected heading instead" % msg
-        )
-
-    angle_avail = common.bin2int(mb[25:27])
-    if angle_avail == 0:
-        return None, "", "N/A"
-    else:
-        angle = common.bin2int(mb[27:36])
-
-        if angle_avail == 1:
-            angle_source = "MCP/FCU"
-        elif angle_avail == 2:
-            angle_source = "Autopilot mode"
-        else:
-            angle_source = "FMS/RNAV"
-
-        angle_type = "Heading" if int(mb[36]) else "Track"
-
-    return angle, angle_type, angle_source
-
-
-def baro_pressure_setting(msg: str) -> None | float:
-    """Decode barometric pressure setting.
-
-    Args:
-        msg (str): 28 hexdigits string
-
-    Returns:
-        float: Barometric pressure setting (millibars)
-
-    """
-
-    if common.typecode(msg) != 29:
-        raise RuntimeError(
-            "%s: Not a target state and status message, expecting TC=29" % msg
-        )
-
-    mb = common.hex2bin(msg)[32:]
-
-    subtype = common.bin2int(mb[5:7])
-
-    if subtype == 0:
-        raise RuntimeError(
-            "%s: ADS-B version 1 target state and status message does not "
-            "contain barometric pressure setting" % msg
-        )
-
-    baro = common.bin2int(mb[20:29])
-    if baro == 0:
-        return None
-
-    return 800 + (baro - 1) * 0.8
-
-
-def autopilot(msg) -> None | bool:
-    """Decode autopilot engagement.
-
-    Args:
-        msg (str): 28 hexdigits string
-
-    Returns:
-        bool: Autopilot engaged
-
-    """
-
-    if common.typecode(msg) != 29:
-        raise RuntimeError(
-            "%s: Not a target state and status message, expecting TC=29" % msg
-        )
-
-    mb = common.hex2bin(msg)[32:]
-
-    subtype = common.bin2int(mb[5:7])
-
-    if subtype == 0:
-        raise RuntimeError(
-            "%s: ADS-B version 1 target state and status message does not "
-            "contain autopilot engagement" % msg
-        )
-
-    if int(mb[46]) == 0:
-        return None
-
-    autopilot = True if int(mb[47]) == 1 else False
-
-    return autopilot
-
-
-def vnav_mode(msg) -> None | bool:
-    """Decode VNAV mode.
-
-    Args:
-        msg (str): 28 hexdigits string
-
-    Returns:
-        bool: VNAV mode engaged
-
-    """
-
-    if common.typecode(msg) != 29:
-        raise RuntimeError(
-            "%s: Not a target state and status message, expecting TC=29" % msg
-        )
-
-    mb = common.hex2bin(msg)[32:]
-
-    subtype = common.bin2int(mb[5:7])
-
-    if subtype == 0:
-        raise RuntimeError(
-            "%s: ADS-B version 1 target state and status message does not "
-            "contain vnav mode, use vertical mode instead" % msg
-        )
-
-    if int(mb[46]) == 0:
-        return None
-
-    vnav_mode = True if int(mb[48]) == 1 else False
-
-    return vnav_mode
-
-
-def altitude_hold_mode(msg) -> None | bool:
-    """Decode altitude hold mode.
-
-    Args:
-        msg (str): 28 hexdigits string
-
-    Returns:
-        bool: Altitude hold mode engaged
-
-    """
-
-    if common.typecode(msg) != 29:
-        raise RuntimeError(
-            "%s: Not a target state and status message, expecting TC=29" % msg
-        )
-
-    mb = common.hex2bin(msg)[32:]
-
-    subtype = common.bin2int(mb[5:7])
-
-    if subtype == 0:
-        raise RuntimeError(
-            "%s: ADS-B version 1 target state and status message does not "
-            "contain altitude hold mode" % msg
-        )
-
-    if int(mb[46]) == 0:
-        return None
-
-    alt_hold_mode = True if int(mb[49]) == 1 else False
-
-    return alt_hold_mode
-
-
-def approach_mode(msg) -> None | bool:
-    """Decode approach mode.
-
-    Args:
-        msg (str): 28 hexdigits string
-
-    Returns:
-        bool: Approach mode engaged
-
-    """
-
-    if common.typecode(msg) != 29:
-        raise RuntimeError(
-            "%s: Not a target state and status message, expecting TC=29" % msg
-        )
-
-    mb = common.hex2bin(msg)[32:]
-
-    subtype = common.bin2int(mb[5:7])
-
-    if subtype == 0:
-        raise RuntimeError(
-            "%s: ADS-B version 1 target state and status message does not "
-            "contain approach mode" % msg
-        )
-
-    if int(mb[46]) == 0:
-        return None
-
-    app_mode = True if int(mb[51]) == 1 else False
-
-    return app_mode
-
-
-def lnav_mode(msg) -> None | bool:
-    """Decode LNAV mode.
-
-    Args:
-        msg (str): 28 hexdigits string
-
-    Returns:
-        bool: LNAV mode engaged
-
-    """
-
-    if common.typecode(msg) != 29:
-        raise RuntimeError(
-            "%s: Not a target state and status message, expecting TC=29" % msg
-        )
-
-    mb = common.hex2bin(msg)[32:]
-
-    subtype = common.bin2int(mb[5:7])
-
-    if subtype == 0:
-        raise RuntimeError(
-            "%s: ADS-B version 1 target state and status message does not "
-            "contain lnav mode, use horizontal mode instead" % msg
-        )
-
-    if int(mb[46]) == 0:
-        return None
-
-    lnav_mode = True if int(mb[53]) == 1 else False
-
-    return lnav_mode
-
-
-def tcas_operational(msg) -> None | bool:
-    """Decode TCAS/ACAS operational.
-
-    Args:
-        msg (str): 28 bytes hexadecimal message string
-
-    Returns:
-        bool: TCAS/ACAS operational
-
-    """
-
-    if common.typecode(msg) != 29:
-        raise RuntimeError(
-            "%s: Not a target state and status message, expecting TC=29" % msg
-        )
-
-    mb = common.hex2bin(msg)[32:]
-
-    subtype = common.bin2int(mb[5:7])
-
-    if subtype == 0:
-        tcas = True if int(mb[51]) == 0 else False
-    else:
-        tcas = True if int(mb[52]) == 1 else False
-
-    return tcas
-
-
-def tcas_ra(msg) -> bool:
-    """Decode TCAS/ACAS Resolution advisory.
-
-    Args:
-        msg (str): 28 bytes hexadecimal message string
-
-    Returns:
-        bool: TCAS/ACAS Resolution advisory active
-
-    """
-
-    if common.typecode(msg) != 29:
-        raise RuntimeError(
-            "%s: Not a target state and status message, expecting TC=29" % msg
-        )
-
-    mb = common.hex2bin(msg)[32:]
-
-    subtype = common.bin2int(mb[5:7])
-
-    if subtype == 1:
-        raise RuntimeError(
-            "%s: ADS-B version 2 target state and status message does not "
-            "contain TCAS/ACAS RA" % msg
-        )
-
-    tcas_ra = True if int(mb[52]) == 1 else False
-
-    return tcas_ra
-
-
-def emergency_status(msg) -> int:
-    """Decode aircraft emergency status.
-
-    Value   Meaning
-    -----   -----------------------
-    0       No emergency
-    1       General emergency
-    2       Lifeguard/medical emergency
-    3       Minimum fuel
-    4       No communications
-    5       Unlawful interference
-    6       Downed aircraft
-    7       Reserved
-
-    Args:
-        msg (str): 28 bytes hexadecimal message string
-
-    Returns:
-        int: Emergency status
-
-    """
-
-    if common.typecode(msg) != 29:
-        raise RuntimeError(
-            "%s: Not a target state and status message, expecting TC=29" % msg
-        )
-
-    mb = common.hex2bin(msg)[32:]
-
-    subtype = common.bin2int(mb[5:7])
-
-    if subtype == 1:
-        raise RuntimeError(
-            "%s: ADS-B version 2 target state and status message does not "
-            "contain emergency status" % msg
-        )
-
-    return common.bin2int(mb[53:56])

pyModeS/decoder/c_common.pxd

@@ -5,8 +5,7 @@ cdef unsigned char int_to_char(unsigned char i)
 
 cpdef str hex2bin(str hexstr)
 cpdef long bin2int(str binstr)
-cpdef long hex2int(str hexstr)
+cpdef long hex2int(str binstr)
-cpdef str bin2hex(str binstr)
 
 cpdef unsigned char df(str msg)
 cpdef long crc(str msg, bint encode=*)
@@ -17,12 +16,8 @@ cpdef bint is_icao_assigned(str icao)
 
 cpdef int typecode(str msg)
 cpdef int cprNL(double lat)
-
 cpdef str idcode(str msg)
-cpdef str squawk(str binstr)
-
 cpdef int altcode(str msg)
-cpdef int altitude(str binstr)
 
-cpdef str data(str msg)
+cdef str data(str msg)
 cpdef bint allzeros(str msg)

pyModeS/decoder/c_common.pyx

@@ -5,7 +5,7 @@ from cpython cimport array
 from cpython.bytes cimport PyBytes_GET_SIZE
 from cpython.bytearray cimport PyByteArray_GET_SIZE
 
-from libc.math cimport abs, cos, acos, fabs, M_PI as pi, floor as c_floor
+from libc.math cimport cos, acos, fabs, M_PI as pi, floor as c_floor
 
 
 cdef int char_to_int(unsigned char binstr):
@@ -25,7 +25,7 @@ cdef unsigned char int_to_char(unsigned char i):
 @cython.boundscheck(False)
 @cython.overflowcheck(False)
 cpdef str hex2bin(str hexstr):
-    """Convert a hexadecimal string to binary string, with zero fillings."""
+    """Convert a hexdecimal string to binary string, with zero fillings."""
     # num_of_bits = len(hexstr) * 4
     cdef hexbytes = bytes(hexstr.encode())
     cdef Py_ssize_t len_hexstr = PyBytes_GET_SIZE(hexbytes)
@@ -66,14 +66,9 @@ cpdef long hex2int(str hexstr):
         cumul = 16*cumul + char_to_int(v_hexstr[i])
     return cumul
 
-@cython.boundscheck(False)
-cpdef str bin2hex(str binstr):
-    return "{0:X}".format(int(binstr, 2))
-
-
 @cython.boundscheck(False)
 cpdef unsigned char df(str msg):
-    """Decode Downlink Format value, bits 1 to 5."""
+    """Decode Downlink Format vaule, bits 1 to 5."""
     cdef str dfbin = hex2bin(msg[:2])
     # return min(bin2int(dfbin[0:5]), 24)
     cdef long df = bin2int(dfbin[0:5])
@@ -160,7 +155,17 @@ cpdef long floor(double x):
     return <long> c_floor(x)
 
 cpdef str icao(str msg):
-    """Calculate the ICAO address from an Mode-S message."""
+    """Calculate the ICAO address from an Mode-S message.
+
+    Applicable only with DF4, DF5, DF20, DF21 messages.
+
+    Args:
+        msg (String): 28 bytes hexadecimal message string
+
+    Returns:
+        String: ICAO address in 6 bytes hexadecimal string
+
+    """
     cdef unsigned char DF = df(msg)
     cdef long c0, c1
 
@@ -207,7 +212,14 @@ cpdef bint is_icao_assigned(str icao):
 @cython.boundscheck(False)
 @cython.wraparound(False)
 cpdef int typecode(str msg):
-    """Type code of ADS-B message"""
+    """Type code of ADS-B message
+
+    Args:
+        msg (string): 28 bytes hexadecimal message string
+
+    Returns:
+        int: type code number
+    """
     if df(msg) not in (17, 18):
         return -1
         # return None
@@ -219,16 +231,18 @@ cpdef int typecode(str msg):
 cpdef int cprNL(double lat):
     """NL() function in CPR decoding."""
 
-    if abs(lat) <= 1e-08:
+    if lat == 0:
         return 59
-    elif abs(abs(lat) - 87) <= 1e-08 + 1e-05 * 87:
+
+    if lat == 87 or lat == -87:
         return 2
-    elif lat > 87 or lat < -87:
+
+    if lat > 87 or lat < -87:
         return 1
 
     cdef int nz = 15
     cdef double a = 1 - cos(pi / (2 * nz))
-    cdef double b = cos(pi / 180 * fabs(lat)) ** 2
+    cdef double b = cos(pi / 180.0 * fabs(lat)) ** 2
     cdef double nl = 2 * pi / (acos(1 - a / b))
     NL = floor(nl)
     return NL
@@ -236,41 +250,45 @@ cpdef int cprNL(double lat):
 @cython.boundscheck(False)
 @cython.wraparound(False)
 cpdef str idcode(str msg):
-    """Compute identity (squawk code)."""
+    """Compute identity (squawk code).
+
+    Applicable only for DF5 or DF21 messages, bit 20-32.
+    credit: @fbyrkjeland
+
+    Args:
+        msg (String): 28 bytes hexadecimal message string
+
+    Returns:
+        string: squawk code
+
+    """
     if df(msg) not in [5, 21]:
         raise RuntimeError("Message must be Downlink Format 5 or 21.")
 
-    squawk_code = squawk(hex2bin(msg)[19:32])
+    cdef bytearray _mbin = bytearray(hex2bin(msg).encode())
-    return squawk_code
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef str squawk(str binstr):
-    """Compute identity (squawk code)."""
-
-    if len(binstr) != 13 or set(binstr) != set('01'):
-        raise RuntimeError("Input must be 13 bits binary string")
-
-    cdef bytearray _mbin = bytearray(binstr.encode())
     cdef unsigned char[:] mbin = _mbin
 
     cdef bytearray _idcode = bytearray(4)
     cdef unsigned char[:] idcode = _idcode
 
-    cdef unsigned char C1 = mbin[0]
+    cdef unsigned char C1 = mbin[19]
-    cdef unsigned char A1 = mbin[1]
+    cdef unsigned char A1 = mbin[20]
-    cdef unsigned char C2 = mbin[2]
+    cdef unsigned char C2 = mbin[21]
-    cdef unsigned char A2 = mbin[3]
+    cdef unsigned char A2 = mbin[22]
-    cdef unsigned char C4 = mbin[4]
+    cdef unsigned char C4 = mbin[23]
-    cdef unsigned char A4 = mbin[5]
+    cdef unsigned char A4 = mbin[24]
-    # X = mbin[6]
+    # _ = mbin[25]
-    cdef unsigned char B1 = mbin[7]
+    cdef unsigned char B1 = mbin[26]
-    cdef unsigned char D1 = mbin[8]
+    cdef unsigned char D1 = mbin[27]
-    cdef unsigned char B2 = mbin[9]
+    cdef unsigned char B2 = mbin[28]
-    cdef unsigned char D2 = mbin[10]
+    cdef unsigned char D2 = mbin[29]
-    cdef unsigned char B4 = mbin[11]
+    cdef unsigned char B4 = mbin[30]
-    cdef unsigned char D4 = mbin[12]
+    cdef unsigned char D4 = mbin[31]
+
+    # byte1 = int(A4 + A2 + A1, 2)
+    # byte2 = int(B4 + B2 + B1, 2)
+    # byte3 = int(C4 + C2 + C1, 2)
+    # byte4 = int(D4 + D2 + D1, 2)
 
     idcode[0] = int_to_char((char_to_int(A4)*2 + char_to_int(A2))*2 + char_to_int(A1))
     idcode[1] = int_to_char((char_to_int(B4)*2 + char_to_int(B2))*2 + char_to_int(B1))
@@ -279,68 +297,68 @@ cpdef str squawk(str binstr):
 
     return _idcode.decode()
 
+    #return str(byte1) + str(byte2) + str(byte3) + str(byte4)
+
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
 cpdef int altcode(str msg):
-    """Compute the altitude."""
+    """Compute the altitude.
+
+    Applicable only for DF4 or DF20 message, bit 20-32.
+    credit: @fbyrkjeland
+
+    Args:
+        msg (String): 28 bytes hexadecimal message string
+
+    Returns:
+        int: altitude in ft
+
+    """
     if df(msg) not in [0, 4, 16, 20]:
         raise RuntimeError("Message must be Downlink Format 0, 4, 16, or 20.")
 
-    alt = altitude(hex2bin(msg)[19:32])
+    # Altitude code, bit 20-32
-    return alt
+    cdef bytearray _mbin = bytearray(hex2bin(msg).encode())
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-cpdef int altitude(str binstr):
-
-    if len(binstr) != 13 or not set(binstr).issubset(set("01")):
-        raise RuntimeError("Input must be 13 bits binary string")
-
-    cdef bytearray _mbin = bytearray(binstr.encode())
     cdef unsigned char[:] mbin = _mbin
 
-    cdef char Mbit = binstr[6]
+    cdef char mbit = mbin[25]  # M bit: 26
-    cdef char Qbit = binstr[8]
+    cdef char qbit = mbin[27]  # Q bit: 28
-
     cdef int alt = 0
     cdef bytearray vbin
     cdef bytearray _graybytes = bytearray(11)
     cdef unsigned char[:] graybytes = _graybytes
 
-    if bin2int(binstr) == 0:
+    if mbit == 48:  # unit in ft, "0" -> 48
-        # altitude unknown or invalid
+        if qbit == 49:  # 25ft interval, "1" -> 49
-        alt = -9999
+            vbin = _mbin[19:25] + _mbin[26:27] + _mbin[28:32]
-
-    elif Mbit == 48:  # unit in ft, "0" -> 48
-        if Qbit == 49:  # 25ft interval, "1" -> 49
-            vbin = _mbin[:6] + _mbin[7:8] + _mbin[9:]
             alt = bin2int(vbin.decode()) * 25 - 1000
-        if Qbit == 48:  # 100ft interval, above 50175ft, "0" -> 48
+        if qbit == 48:  # 100ft interval, above 50175ft, "0" -> 48
-            graybytes[8] = mbin[0]
+            graybytes[8] = mbin[19]
-            graybytes[2] = mbin[1]
+            graybytes[2] = mbin[20]
-            graybytes[9] = mbin[2]
+            graybytes[9] = mbin[21]
-            graybytes[3] = mbin[3]
+            graybytes[3] = mbin[22]
-            graybytes[10] = mbin[4]
+            graybytes[10] = mbin[23]
-            graybytes[4] = mbin[5]
+            graybytes[4] = mbin[24]
-            # M = mbin[6]
+            # _ = mbin[25]
-            graybytes[5] = mbin[7]
+            graybytes[5] = mbin[26]
-            # Q = mbin[8]
+            # cdef char D1 = mbin[27]  # always zero
-            graybytes[6] = mbin[9]
+            graybytes[6] = mbin[28]
-            graybytes[0] = mbin[10]
+            graybytes[0] = mbin[29]
-            graybytes[7] = mbin[11]
+            graybytes[7] = mbin[30]
-            graybytes[1] = mbin[12]
+            graybytes[1] = mbin[31]
+            # graybytes = D2 + D4 + A1 + A2 + A4 + B1 + B2 + B4 + C1 + C2 + C4
 
             alt = gray2alt(_graybytes.decode())
 
-    elif Mbit == 49:  # unit in meter, "1" -> 49
+    if mbit == 49:  # unit in meter, "1" -> 49
-        vbin = _mbin[:6] + _mbin[7:]
+        vbin = _mbin[19:25] + _mbin[26:31]
         alt = int(bin2int(vbin.decode()) * 3.28084)  # convert to ft
 
     return alt
 
 
+
 cpdef int gray2alt(str codestr):
     cdef str gc500 = codestr[:8]
     cdef int n500 = gray2int(gc500)
@@ -373,13 +391,21 @@ cdef int gray2int(str graystr):
     return num
 
 
-cpdef str data(str msg):
+cdef str data(str msg):
     """Return the data frame in the message, bytes 9 to 22."""
     return msg[8:-6]
 
 
 cpdef bint allzeros(str msg):
-    """Check if the data bits are all zeros."""
+    """Check if the data bits are all zeros.
+
+    Args:
+        msg (String): 28 bytes hexadecimal message string
+
+    Returns:
+        bool: True or False
+
+    """
     d = hex2bin(data(msg))
 
     if bin2int(d) > 0:

pyModeS/decoder/commb.py

@@ -1,88 +1,37 @@
-"""Comm-B module.
+"""Comm-B Wrapper.
 
-The Comm-B module imports all functions from the following modules:
+The Comm-B wrapper imports all functions from the following modules:
 
-ELS - elementary surveillance
+**ELS - elementary surveillance**
+    - pyModeS.decoder.bds.bds10
+    - pyModeS.decoder.bds.bds17
+    - pyModeS.decoder.bds.bds20
+    - pyModeS.decoder.bds.bds30
 
-- pyModeS.decoder.bds.bds10
+**EHS - enhanced surveillance**
-- pyModeS.decoder.bds.bds17
+    - pyModeS.decoder.bds.bds40
-- pyModeS.decoder.bds.bds20
+    - pyModeS.decoder.bds.bds50
-- pyModeS.decoder.bds.bds30
+    - pyModeS.decoder.bds.bds60
 
-EHS - enhanced surveillance
+**MRAR and MHR**
-
+    - pyModeS.decoder.bds.bds44
-- pyModeS.decoder.bds.bds40
+    - pyModeS.decoder.bds.bds45
-- pyModeS.decoder.bds.bds50
-- pyModeS.decoder.bds.bds60
-
-MRAR and MHR
-
-- pyModeS.decoder.bds.bds44
-- pyModeS.decoder.bds.bds45
 
 """
 
+from __future__ import absolute_import, print_function, division
+
 # ELS - elementary surveillance
-from .bds.bds10 import is10, ovc10
+from pyModeS.decoder.bds.bds10 import *
-from .bds.bds17 import is17, cap17
+from pyModeS.decoder.bds.bds17 import *
-from .bds.bds20 import is20, cs20
+from pyModeS.decoder.bds.bds20 import *
-from .bds.bds30 import is30
+from pyModeS.decoder.bds.bds30 import *
 
 # ELS - enhanced surveillance
-from .bds.bds40 import (
+from pyModeS.decoder.bds.bds40 import *
-    is40,
+from pyModeS.decoder.bds.bds50 import *
-    selalt40fms,
+from pyModeS.decoder.bds.bds60 import *
-    selalt40mcp,
-    p40baro,
-    alt40fms,
-    alt40mcp,
-)
-from .bds.bds50 import is50, roll50, trk50, gs50, rtrk50, tas50
-from .bds.bds60 import is60, hdg60, ias60, mach60, vr60baro, vr60ins
 
 # MRAR and MHR
-from .bds.bds44 import is44, wind44, temp44, p44, hum44, turb44
+from pyModeS.decoder.bds.bds44 import *
-from .bds.bds45 import is45, turb45, ws45, mb45, ic45, wv45, temp45, p45, rh45
+from pyModeS.decoder.bds.bds45 import *
-
-__all__ = [
-    "is10",
-    "ovc10",
-    "is17",
-    "cap17",
-    "is20",
-    "cs20",
-    "is30",
-    "is40",
-    "selalt40fms",
-    "selalt40mcp",
-    "p40baro",
-    "alt40fms",
-    "alt40mcp",
-    "is50",
-    "roll50",
-    "trk50",
-    "gs50",
-    "rtrk50",
-    "tas50",
-    "is60",
-    "hdg60",
-    "ias60",
-    "mach60",
-    "vr60baro",
-    "vr60ins",
-    "is44",
-    "wind44",
-    "temp44",
-    "p44",
-    "hum44",
-    "turb44",
-    "is45",
-    "turb45",
-    "ws45",
-    "mb45",
-    "ic45",
-    "wv45",
-    "temp45",
-    "p45",
-    "rh45",
-]

pyModeS/decoder/common.py

@@ -1,46 +1,40 @@
-from typing import Optional
+from __future__ import absolute_import, print_function, division
-
 import numpy as np
 from textwrap import wrap
 
 
-def hex2bin(hexstr: str) -> str:
+def hex2bin(hexstr):
-    """Convert a hexadecimal string to binary string, with zero fillings."""
+    """Convert a hexdecimal string to binary string, with zero fillings."""
     num_of_bits = len(hexstr) * 4
     binstr = bin(int(hexstr, 16))[2:].zfill(int(num_of_bits))
     return binstr
 
 
-def hex2int(hexstr: str) -> int:
+def hex2int(hexstr):
-    """Convert a hexadecimal string to integer."""
+    """Convert a hexdecimal string to integer."""
     return int(hexstr, 16)
 
 
-def bin2int(binstr: str) -> int:
+def bin2int(binstr):
     """Convert a binary string to integer."""
     return int(binstr, 2)
 
 
-def bin2hex(binstr: str) -> str:
+def df(msg):
-    """Convert a binary string to hexadecimal string."""
+    """Decode Downlink Format vaule, bits 1 to 5."""
-    return "{0:X}".format(int(binstr, 2))
-
-
-def df(msg: str) -> int:
-    """Decode Downlink Format value, bits 1 to 5."""
     dfbin = hex2bin(msg[:2])
     return min(bin2int(dfbin[0:5]), 24)
 
 
-def crc(msg: str, encode: bool = False) -> int:
+def crc(msg, encode=False):
     """Mode-S Cyclic Redundancy Check.
 
     Detect if bit error occurs in the Mode-S message. When encode option is on,
     the checksum is generated.
 
     Args:
-        msg: 28 bytes hexadecimal message string
+        msg (string): 28 bytes hexadecimal message string
-        encode: True to encode the date only and return the checksum
+        encode (bool): True to encode the date only and return the checksum
     Returns:
         int: message checksum, or partity bits (encoder)
 
@@ -77,7 +71,7 @@ def crc(msg: str, encode: bool = False) -> int:
     return result
 
 
-def crc_legacy(msg: str, encode: bool = False) -> int:
+def crc_legacy(msg, encode=False):
     """Mode-S Cyclic Redundancy Check. (Legacy code, 2x slow)."""
     # the polynominal generattor code for CRC [1111111111111010000001001]
     generator = np.array(
@@ -105,7 +99,7 @@ def crc_legacy(msg: str, encode: bool = False) -> int:
     return reminder
 
 
-def floor(x: float) -> int:
+def floor(x):
     """Mode-S floor function.
 
     Defined as the greatest integer value k, such that k <= x
@@ -115,7 +109,7 @@ def floor(x: float) -> int:
     return int(np.floor(x))
 
 
-def icao(msg: str) -> Optional[str]:
+def icao(msg):
     """Calculate the ICAO address from an Mode-S message.
 
     Applicable only with DF4, DF5, DF20, DF21 messages.
@@ -127,7 +121,6 @@ def icao(msg: str) -> Optional[str]:
         String: ICAO address in 6 bytes hexadecimal string
 
     """
-    addr: Optional[str]
     DF = df(msg)
 
     if DF in (11, 17, 18):
@@ -142,7 +135,7 @@ def icao(msg: str) -> Optional[str]:
     return addr
 
 
-def is_icao_assigned(icao: str) -> bool:
+def is_icao_assigned(icao):
     """Check whether the ICAO address is assigned (Annex 10, Vol 3)."""
     if (icao is None) or (not isinstance(icao, str)) or (len(icao) != 6):
         return False
@@ -171,7 +164,7 @@ def is_icao_assigned(icao: str) -> bool:
     return True
 
 
-def typecode(msg: str) -> Optional[int]:
+def typecode(msg):
     """Type code of ADS-B message
 
     Args:
@@ -187,26 +180,31 @@ def typecode(msg: str) -> Optional[int]:
     return bin2int(tcbin[0:5])
 
 
-def cprNL(lat: float) -> int:
+def cprNL(lat):
     """NL() function in CPR decoding."""
 
-    if np.isclose(lat, 0):
+    if lat == 0:
         return 59
-    elif np.isclose(abs(lat), 87):
+
+    if lat == 87 or lat == -87:
         return 2
-    elif lat > 87 or lat < -87:
+
+    if lat > 87 or lat < -87:
         return 1
 
     nz = 15
     a = 1 - np.cos(np.pi / (2 * nz))
-    b = np.cos(np.pi / 180 * abs(lat)) ** 2
+    b = np.cos(np.pi / 180.0 * abs(lat)) ** 2
     nl = 2 * np.pi / (np.arccos(1 - a / b))
     NL = floor(nl)
     return NL
 
 
-def idcode(msg: str) -> str:
+def idcode(msg):
-    """Compute identity code (squawk) encoded in DF5 or DF21 message.
+    """Compute identity (squawk code).
+
+    Applicable only for DF5 or DF21 messages, bit 20-32.
+    credit: @fbyrkjeland
 
     Args:
         msg (String): 28 bytes hexadecimal message string
@@ -219,37 +217,20 @@ def idcode(msg: str) -> str:
         raise RuntimeError("Message must be Downlink Format 5 or 21.")
 
     mbin = hex2bin(msg)
-    idcodebin = mbin[19:32]
 
-    return squawk(idcodebin)
+    C1 = mbin[19]
-
+    A1 = mbin[20]
-
+    C2 = mbin[21]
-def squawk(binstr: str) -> str:
+    A2 = mbin[22]
-    """Decode 13 bits identity (squawk) code.
+    C4 = mbin[23]
-
+    A4 = mbin[24]
-    Args:
+    # _ = mbin[25]
-        binstr (String): 13 bits binary string
+    B1 = mbin[26]
-
+    D1 = mbin[27]
-    Returns:
+    B2 = mbin[28]
-        int: altitude in ft
+    D2 = mbin[29]
-
+    B4 = mbin[30]
-    """
+    D4 = mbin[31]
-    if len(binstr) != 13 or not set(binstr).issubset(set("01")):
-        raise RuntimeError("Input must be 13 bits binary string")
-
-    C1 = binstr[0]
-    A1 = binstr[1]
-    C2 = binstr[2]
-    A2 = binstr[3]
-    C4 = binstr[4]
-    A4 = binstr[5]
-    # X = binstr[6]
-    B1 = binstr[7]
-    D1 = binstr[8]
-    B2 = binstr[9]
-    D2 = binstr[10]
-    B4 = binstr[11]
-    D4 = binstr[12]
 
     byte1 = int(A4 + A2 + A1, 2)
     byte2 = int(B4 + B2 + B1, 2)
@@ -259,8 +240,11 @@ def squawk(binstr: str) -> str:
     return str(byte1) + str(byte2) + str(byte3) + str(byte4)
 
 
-def altcode(msg: str) -> Optional[int]:
+def altcode(msg):
-    """Compute altitude encoded in DF4 or DF20 message.
+    """Compute the altitude.
+
+    Applicable only for DF4 or DF20 message, bit 20-32.
+    credit: @fbyrkjeland
 
     Args:
         msg (String): 28 bytes hexadecimal message string
@@ -269,78 +253,50 @@ def altcode(msg: str) -> Optional[int]:
         int: altitude in ft
 
     """
-    alt: Optional[int]
-
     if df(msg) not in [0, 4, 16, 20]:
         raise RuntimeError("Message must be Downlink Format 0, 4, 16, or 20.")
 
     # Altitude code, bit 20-32
     mbin = hex2bin(msg)
 
-    altitude_code = mbin[19:32]
+    mbit = mbin[25]  # M bit: 26
+    qbit = mbin[27]  # Q bit: 28
 
-    alt = altitude(altitude_code)
+    if mbit == "0":  # unit in ft
-
+        if qbit == "1":  # 25ft interval
-    return alt
+            vbin = mbin[19:25] + mbin[26] + mbin[28:32]
-
-
-def altitude(binstr: str) -> Optional[int]:
-    """Decode 13 bits altitude code.
-
-    Args:
-        binstr (String): 13 bits binary string
-
-    Returns:
-        int: altitude in ft
-
-    """
-    alt: Optional[int]
-
-    if len(binstr) != 13 or not set(binstr).issubset(set("01")):
-        raise RuntimeError("Input must be 13 bits binary string")
-
-    Mbit = binstr[6]
-    Qbit = binstr[8]
-
-    if bin2int(binstr) == 0:
-        # altitude unknown or invalid
-        alt = None
-
-    elif Mbit == "0":  # unit in ft
-        if Qbit == "1":  # 25ft interval
-            vbin = binstr[:6] + binstr[7] + binstr[9:]
             alt = bin2int(vbin) * 25 - 1000
-        if Qbit == "0":  # 100ft interval, above 50187.5ft
+        if qbit == "0":  # 100ft interval, above 50175ft
-            C1 = binstr[0]
+            C1 = mbin[19]
-            A1 = binstr[1]
+            A1 = mbin[20]
-            C2 = binstr[2]
+            C2 = mbin[21]
-            A2 = binstr[3]
+            A2 = mbin[22]
-            C4 = binstr[4]
+            C4 = mbin[23]
-            A4 = binstr[5]
+            A4 = mbin[24]
-            # M = binstr[6]
+            # _ = mbin[25]
-            B1 = binstr[7]
+            B1 = mbin[26]
-            # Q = binstr[8]
+            # D1 = mbin[27]     # always zero
-            B2 = binstr[9]
+            B2 = mbin[28]
-            D2 = binstr[10]
+            D2 = mbin[29]
-            B4 = binstr[11]
+            B4 = mbin[30]
-            D4 = binstr[12]
+            D4 = mbin[31]
 
             graystr = D2 + D4 + A1 + A2 + A4 + B1 + B2 + B4 + C1 + C2 + C4
             alt = gray2alt(graystr)
 
-    if Mbit == "1":  # unit in meter
+    if mbit == "1":  # unit in meter
-        vbin = binstr[:6] + binstr[7:]
+        vbin = mbin[19:25] + mbin[26:31]
         alt = int(bin2int(vbin) * 3.28084)  # convert to ft
 
     return alt
 
 
-def gray2alt(binstr: str) -> Optional[int]:
+def gray2alt(codestr):
-    gc500 = binstr[:8]
+    gc500 = codestr[:8]
     n500 = gray2int(gc500)
 
     # in 100-ft step must be converted first
-    gc100 = binstr[8:]
+    gc100 = codestr[8:]
     n100 = gray2int(gc100)
 
     if n100 in [0, 5, 6]:
@@ -356,9 +312,9 @@ def gray2alt(binstr: str) -> Optional[int]:
     return alt
 
 
-def gray2int(binstr: str) -> int:
+def gray2int(graystr):
     """Convert greycode to binary."""
-    num = bin2int(binstr)
+    num = bin2int(graystr)
     num ^= num >> 8
     num ^= num >> 4
     num ^= num >> 2
@@ -366,12 +322,12 @@ def gray2int(binstr: str) -> int:
     return num
 
 
-def data(msg: str) -> str:
+def data(msg):
     """Return the data frame in the message, bytes 9 to 22."""
     return msg[8:-6]
 
 
-def allzeros(msg: str) -> bool:
+def allzeros(msg):
     """Check if the data bits are all zeros.
 
     Args:
@@ -389,7 +345,7 @@ def allzeros(msg: str) -> bool:
         return True
 
 
-def wrongstatus(data: str, sb: int, msb: int, lsb: int) -> bool:
+def wrongstatus(data, sb, msb, lsb):
     """Check if the status bit and field bits are consistency.
 
     This Function is used for checking BDS code versions.
@@ -404,85 +360,3 @@ def wrongstatus(data: str, sb: int, msb: int, lsb: int) -> bool:
             return True
 
     return False
-
-
-def fs(msg):
-    """Decode flight status for DF 4, 5, 20, and 21.
-
-    Args:
-        msg (str): 14 hexdigits string
-    Returns:
-        int, str: flight status, description
-
-    """
-    msgbin = hex2bin(msg)
-    fs = bin2int(msgbin[5:8])
-    text = None
-
-    if fs == 0:
-        text = "no alert, no SPI, aircraft is airborne"
-    elif fs == 1:
-        text = "no alert, no SPI, aircraft is on-ground"
-    elif fs == 2:
-        text = "alert, no SPI, aircraft is airborne"
-    elif fs == 3:
-        text = "alert, no SPI, aircraft is on-ground"
-    elif fs == 4:
-        text = "alert, SPI, aircraft is airborne or on-ground"
-    elif fs == 5:
-        text = "no alert, SPI, aircraft is airborne or on-ground"
-
-    return fs, text
-
-
-def dr(msg):
-    """Decode downlink request for DF 4, 5, 20, and 21.
-
-    Args:
-        msg (str): 14 hexdigits string
-    Returns:
-        int, str: downlink request, description
-
-    """
-    msgbin = hex2bin(msg)
-    dr = bin2int(msgbin[8:13])
-
-    text = None
-
-    if dr == 0:
-        text = "no downlink request"
-    elif dr == 1:
-        text = "request to send Comm-B message"
-    elif dr == 4:
-        text = "Comm-B broadcast 1 available"
-    elif dr == 5:
-        text = "Comm-B broadcast 2 available"
-    elif dr >= 16:
-        text = "ELM downlink segments available: {}".format(dr - 15)
-
-    return dr, text
-
-
-def um(msg):
-    """Decode utility message for DF 4, 5, 20, and 21.
-
-    Utility message contains interrogator identifier and reservation type.
-
-    Args:
-        msg (str): 14 hexdigits string
-    Returns:
-        int, str: interrogator identifier code that triggered the reply, and
-        reservation type made by the interrogator
-    """
-    msgbin = hex2bin(msg)
-    iis = bin2int(msgbin[13:17])
-    ids = bin2int(msgbin[17:19])
-    if ids == 0:
-        ids_text = None
-    if ids == 1:
-        ids_text = "Comm-B interrogator identifier code"
-    if ids == 2:
-        ids_text = "Comm-C interrogator identifier code"
-    if ids == 3:
-        ids_text = "Comm-D interrogator identifier code"
-    return iis, ids, ids_text

pyModeS/decoder/ehs.py

@@ -9,58 +9,28 @@ The EHS wrapper imports all functions from the following modules:
 
 """
 
+from __future__ import absolute_import, print_function, division
 import warnings
 
-from .bds.bds40 import (
+from pyModeS.decoder.bds.bds40 import *
-    is40,
+from pyModeS.decoder.bds.bds50 import *
-    selalt40fms,
+from pyModeS.decoder.bds.bds60 import *
-    selalt40mcp,
+from pyModeS.decoder.bds import infer
-    p40baro,
-    alt40fms,
-    alt40mcp,
-)
-from .bds.bds50 import is50, roll50, trk50, gs50, rtrk50, tas50
-from .bds.bds60 import is60, hdg60, ias60, mach60, vr60baro, vr60ins
-from .bds import infer
-
-__all__ = [
-    "is40",
-    "selalt40fms",
-    "selalt40mcp",
-    "p40baro",
-    "alt40fms",
-    "alt40mcp",
-    "is50",
-    "roll50",
-    "trk50",
-    "gs50",
-    "rtrk50",
-    "tas50",
-    "is60",
-    "hdg60",
-    "ias60",
-    "mach60",
-    "vr60baro",
-    "vr60ins",
-    "infer",
-]
 
 warnings.simplefilter("once", DeprecationWarning)
 warnings.warn(
-    "pms.ehs module is deprecated. Please use pms.commb instead.",
+    "pms.ehs module is deprecated. Please use pms.commb instead.", DeprecationWarning
-    DeprecationWarning,
 )
 
 
 def BDS(msg):
     warnings.warn(
-        "pms.ehs.BDS() is deprecated, use pms.bds.infer() instead.",
+        "pms.ehs.BDS() is deprecated, use pms.bds.infer() instead.", DeprecationWarning
-        DeprecationWarning,
     )
     return infer(msg)
 
 
 def icao(msg):
-    from . import common
+    from pyModeS.decoder.common import icao
 
-    return common.icao(msg)
+    return icao(msg)

pyModeS/decoder/els.py

@@ -10,26 +10,16 @@ The ELS wrapper imports all functions from the following modules:
 
 """
 
-import warnings
+from __future__ import absolute_import, print_function, division
 
-from .bds.bds10 import is10, ovc10
+from pyModeS.decoder.bds.bds10 import *
-from .bds.bds17 import cap17, is17
+from pyModeS.decoder.bds.bds17 import *
-from .bds.bds20 import cs20, is20
+from pyModeS.decoder.bds.bds20 import *
-from .bds.bds30 import is30
+from pyModeS.decoder.bds.bds30 import *
+
+import warnings
 
 warnings.simplefilter("once", DeprecationWarning)
 warnings.warn(
-    "pms.els module is deprecated. Please use pms.commb instead.",
+    "pms.els module is deprecated. Please use pms.commb instead.", DeprecationWarning
-    DeprecationWarning,
 )
-
-
-__all__ = [
-    "is10",
-    "ovc10",
-    "is17",
-    "cap17",
-    "is20",
-    "cs20",
-    "is30",
-]

pyModeS/decoder/flarm/__init__.py

@@ -1,25 +0,0 @@
-from typing import TypedDict
-
-from .decode import flarm as flarm_decode
-
-__all__ = ["DecodedMessage", "flarm"]
-
-
-class DecodedMessage(TypedDict):
-    timestamp: int
-    icao24: str
-    latitude: float
-    longitude: float
-    altitude: int
-    vertical_speed: float
-    groundspeed: int
-    track: int
-    type: str
-    sensorLatitude: float
-    sensorLongitude: float
-    isIcao24: bool
-    noTrack: bool
-    stealth: bool
-
-
-flarm = flarm_decode

pyModeS/decoder/flarm/core.c

@@ -1,124 +0,0 @@
-#include "core.h"
-
-/*
- *
- * https://pastebin.com/YK2f8bfm
- *
- * NEW ENCRYPTION
- *
- * Swiss glider anti-colission system moved to a new encryption scheme: XXTEA
- * The algorithm encrypts all the packet after the header: total 20 bytes or 5 long int words of data
- *
- * XXTEA description and code are found here: http://en.wikipedia.org/wiki/XXTEA
- * The system uses 6 iterations of the main loop.
- *
- * The system version 6 sends two type of packets: position and ... some unknown data
- * The difference is made by bit 0 of byte 3 of the packet: for position data this bit is zero.
- *
- * For position data the key used depends on the time and transmitting device address.
- * The key is as well obscured by a weird algorithm.
- * The code to generate the key is:
- *
- * */
-
-void make_key(int *key, long time, long address)
-{
-  const long key1[4] = {0xe43276df, 0xdca83759, 0x9802b8ac, 0x4675a56b};
-  const long key1b[4] = {0xfc78ea65, 0x804b90ea, 0xb76542cd, 0x329dfa32};
-  const long *table = ((((time >> 23) & 255) & 0x01) != 0) ? key1b : key1;
-
-  for (int i = 0; i < 4; i++)
-  {
-    key[i] = obscure(table[i] ^ ((time >> 6) ^ address), 0x045D9F3B) ^ 0x87B562F4;
-  }
-}
-
-long obscure(long key, unsigned long seed)
-{
-  unsigned int m1 = seed * (key ^ (key >> 16));
-  unsigned int m2 = seed * (m1 ^ (m1 >> 16));
-  return m2 ^ (m2 >> 16);
-}
-
-/*
- * NEW PACKET FORMAT:
- *
- * Byte     Bits
- *  0     AAAA AAAA    device address
- *  1     AAAA AAAA
- *  2     AAAA AAAA
- *  3     00aa 0000    aa = 10 or 01
- *
- *  4     vvvv vvvv    vertical speed
- *  5     xxxx xxvv
- *  6     gggg gggg    GPS status
- *  7     tttt gggg    plane type
- *
- *  8     LLLL LLLL    Latitude
- *  9     LLLL LLLL
- * 10     aaaa aLLL
- * 11     aaaa aaaa    Altitude
- *
- * 12     NNNN NNNN    Longitude
- * 13     NNNN NNNN
- * 14     xxxx NNNN
- * 15     FFxx xxxx    multiplying factor
- *
- * 16     SSSS SSSS    as in version 4
- * 17     ssss ssss
- * 18     KKKK KKKK
- * 19     kkkk kkkk
- *
- * 20     EEEE EEEE
- * 21     eeee eeee
- * 22     PPPP PPPP
- * 24     pppp pppp
- * */
-
-/*
- * https://en.wikipedia.org/wiki/XXTEA
- */
-
-void btea(uint32_t *v, int n, uint32_t const key[4])
-{
-  uint32_t y, z, sum;
-  unsigned p, rounds, e;
-  if (n > 1)
-  { /* Coding Part */
-    /* Unused, should remove? */
-    rounds = 6 + 52 / n;
-    sum = 0;
-    z = v[n - 1];
-    do
-    {
-      sum += DELTA;
-      e = (sum >> 2) & 3;
-      for (p = 0; p < (unsigned)n - 1; p++)
-      {
-        y = v[p + 1];
-        z = v[p] += MX;
-      }
-      y = v[0];
-      z = v[n - 1] += MX;
-    } while (--rounds);
-  }
-  else if (n < -1)
-  { /* Decoding Part */
-    n = -n;
-    rounds = 6; // + 52 / n;
-    sum = rounds * DELTA;
-    y = v[0];
-    do
-    {
-      e = (sum >> 2) & 3;
-      for (p = n - 1; p > 0; p--)
-      {
-        z = v[p - 1];
-        y = v[p] -= MX;
-      }
-      z = v[n - 1];
-      y = v[0] -= MX;
-      sum -= DELTA;
-    } while (--rounds);
-  }
-}

pyModeS/decoder/flarm/core.h

@@ -1,13 +0,0 @@
-#ifndef __CORE_H__
-#define __CORE_H__
-
-#include <stdint.h>
-
-#define DELTA 0x9e3779b9
-#define MX (((z >> 5 ^ y << 2) + (y >> 3 ^ z << 4)) ^ ((sum ^ y) + (key[(p & 3) ^ e] ^ z)))
-
-void make_key(int *key, long time, long address);
-long obscure(long key, unsigned long seed);
-void btea(uint32_t *v, int n, uint32_t const key[4]);
-
-#endif

pyModeS/decoder/flarm/core.pxd

@@ -1,4 +0,0 @@
-
-cdef extern from "core.h":
-    void make_key(int*, long time, long address)
-    void btea(int*, int, int*)

pyModeS/decoder/flarm/decode.pyi

@@ -1,14 +0,0 @@
-from typing import Any
-
-from . import DecodedMessage
-
-AIRCRAFT_TYPES: list[str]
-
-
-def flarm(
-    timestamp: int,
-    msg: str,
-    refLat: float,
-    refLon: float,
-    **kwargs: Any,
-) -> DecodedMessage: ...

pyModeS/decoder/flarm/decode.pyx

@@ -1,145 +0,0 @@
-from core cimport make_key as c_make_key, btea as c_btea
-from cpython cimport array
-
-import array
-import math
-from ctypes import c_byte
-from textwrap import wrap
-
-AIRCRAFT_TYPES = [
-    "Unknown",  # 0
-    "Glider",  # 1
-    "Tow-Plane",  # 2
-    "Helicopter",  # 3
-    "Parachute",  # 4
-    "Parachute Drop-Plane",  # 5
-    "Hangglider",  # 6
-    "Paraglider",  # 7
-    "Aircraft",  # 8
-    "Jet",  # 9
-    "UFO",  # 10
-    "Balloon",  # 11
-    "Airship",  # 12
-    "UAV",  # 13
-    "Reserved",  # 14
-    "Static Obstacle",  # 15
-]
-
-cdef long bytearray2int(str icao24):
-    return (
-        (int(icao24[4:6], 16) & 0xFF)
-        | ((int(icao24[2:4], 16) & 0xFF) << 8)
-        | ((int(icao24[:2], 16) & 0xFF) << 16)
-    )
-
-cpdef array.array make_key(long timestamp, str icao24):
-    cdef long addr = bytearray2int(icao24)
-    cdef array.array a = array.array('i', [0, 0, 0, 0])
-    c_make_key(a.data.as_ints, timestamp, (addr << 8) & 0xffffff)
-    return a
-
-cpdef array.array btea(long timestamp, str msg):
-    cdef int p
-    cdef str icao24 = msg[4:6] + msg[2:4] + msg[:2]
-    cdef array.array key = make_key(timestamp, icao24)
-
-    pieces = wrap(msg[8:], 8)
-    cdef array.array toDecode = array.array('i', len(pieces) * [0])
-    for i, piece in enumerate(pieces):
-        p = 0
-        for elt in wrap(piece, 2)[::-1]:
-            p = (p << 8) + int(elt, 16)
-        toDecode[i] = p
-
-    c_btea(toDecode.data.as_ints, -5, key.data.as_ints)
-    return toDecode
-
-cdef float velocity(int ns, int ew):
-    return math.hypot(ew / 4, ns / 4)
-
-def heading(ns, ew, velocity):
-    if velocity < 1e-6:
-        velocity = 1
-    return (math.atan2(ew / velocity / 4, ns / velocity / 4) / 0.01745) % 360
-
-def turningRate(a1, a2):
-    return ((((a2 - a1)) + 540) % 360) - 180
-
-def flarm(long timestamp, str msg, float refLat, float refLon, **kwargs):
-    """Decode a FLARM message.
-
-    Args:
-        timestamp (int)
-        msg (str)
-        refLat (float): the receiver's location
-        refLon (float): the receiver's location
-
-    Returns:
-        a dictionary with all decoded fields. Any extra keyword argument passed
-        is included in the output dictionary.
-    """
-    cdef str icao24 = msg[4:6] + msg[2:4] + msg[:2]
-    cdef int magic = int(msg[6:8], 16)
-
-    if magic != 0x10 and magic != 0x20:
-        return None
-
-    cdef array.array decoded = btea(timestamp, msg)
-
-    cdef int aircraft_type = (decoded[0] >> 28) & 0xF
-    cdef int gps = (decoded[0] >> 16) & 0xFFF
-    cdef int raw_vs = c_byte(decoded[0] & 0x3FF).value
-
-    noTrack = ((decoded[0] >> 14) & 0x1) == 1
-    stealth = ((decoded[0] >> 13) & 0x1) == 1
-
-    cdef int altitude =  (decoded[1] >> 19) & 0x1FFF
-
-    cdef int lat = decoded[1] & 0x7FFFF
-
-    cdef int mult_factor = 1 << ((decoded[2] >> 30) & 0x3)
-    cdef int lon = decoded[2] & 0xFFFFF
-
-    ns = list(
-        c_byte((decoded[3] >> (i * 8)) & 0xFF).value * mult_factor
-        for i in range(4)
-    )
-    ew = list(
-        c_byte((decoded[4] >> (i * 8)) & 0xFF).value * mult_factor
-        for i in range(4)
-    )
-
-    cdef int roundLat = int(refLat * 1e7) >> 7
-    lat = (lat - roundLat) % 0x080000
-    if lat >= 0x040000:
-        lat -= 0x080000
-    lat = (((lat + roundLat) << 7) + 0x40) 
-
-    roundLon = int(refLon * 1e7) >> 7
-    lon = (lon - roundLon) % 0x100000
-    if lon >= 0x080000:
-        lon -= 0x100000
-    lon = (((lon + roundLon) << 7) + 0x40)
-
-    speed = sum(velocity(n, e) for n, e in zip(ns, ew)) / 4
-
-    heading4 = heading(ns[0], ew[0], speed)
-    heading8 = heading(ns[1], ew[1], speed)
-
-    return dict(
-        timestamp=timestamp,
-        icao24=icao24,
-        latitude=round(lat * 1e-7, 6),
-        longitude=round(lon * 1e-7, 6),
-        geoaltitude=altitude,
-        vertical_speed=raw_vs * mult_factor / 10,
-        groundspeed=round(speed),
-        track=round(heading4 - 4 * turningRate(heading4, heading8) / 4),
-        type=AIRCRAFT_TYPES[aircraft_type],
-        sensorLatitude=refLat,
-        sensorLongitude=refLon,
-        isIcao24=magic==0x10,
-        noTrack=noTrack,
-        stealth=stealth,
-        **kwargs
-    )

pyModeS/decoder/surv.py

@@ -1,138 +1,8 @@
 """
-Decode short roll call surveillance replies, with downlink format 4 or 5
+Warpper for short roll call surveillance replies DF=4/5
+
+[To be implemented]
 """
 
-from __future__ import annotations
+from __future__ import absolute_import, print_function, division
-from typing import Callable, TypeVar
+from pyModeS.decoder import common
-
-from .. import common
-
-T = TypeVar("T")
-F = Callable[[str], T]
-
-
-def _checkdf(func: F[T]) -> F[T]:
-    """Ensure downlink format is 4 or 5."""
-
-    def wrapper(msg: str) -> T:
-        df = common.df(msg)
-        if df not in [4, 5]:
-            raise RuntimeError(
-                "Incorrect downlink format, expect 4 or 5, got {}".format(df)
-            )
-        return func(msg)
-
-    return wrapper
-
-
-@_checkdf
-def fs(msg: str) -> tuple[int, str]:
-    """Decode flight status.
-
-    Args:
-        msg (str): 14 hexdigits string
-    Returns:
-        int, str: flight status, description
-
-    """
-    msgbin = common.hex2bin(msg)
-    fs = common.bin2int(msgbin[5:8])
-    text = ""
-
-    if fs == 0:
-        text = "no alert, no SPI, aircraft is airborne"
-    elif fs == 1:
-        text = "no alert, no SPI, aircraft is on-ground"
-    elif fs == 2:
-        text = "alert, no SPI, aircraft is airborne"
-    elif fs == 3:
-        text = "alert, no SPI, aircraft is on-ground"
-    elif fs == 4:
-        text = "alert, SPI, aircraft is airborne or on-ground"
-    elif fs == 5:
-        text = "no alert, SPI, aircraft is airborne or on-ground"
-
-    return fs, text
-
-
-@_checkdf
-def dr(msg: str) -> tuple[int, str]:
-    """Decode downlink request.
-
-    Args:
-        msg (str): 14 hexdigits string
-    Returns:
-        int, str: downlink request, description
-
-    """
-    msgbin = common.hex2bin(msg)
-    dr = common.bin2int(msgbin[8:13])
-
-    text = ""
-
-    if dr == 0:
-        text = "no downlink request"
-    elif dr == 1:
-        text = "request to send Comm-B message"
-    elif dr == 4:
-        text = "Comm-B broadcast 1 available"
-    elif dr == 5:
-        text = "Comm-B broadcast 2 available"
-    elif dr >= 16:
-        text = "ELM downlink segments available: {}".format(dr - 15)
-
-    return dr, text
-
-
-@_checkdf
-def um(msg: str) -> tuple[int, int, None | str]:
-    """Decode utility message.
-
-    Utility message contains interrogator identifier and reservation type.
-
-    Args:
-        msg (str): 14 hexdigits string
-    Returns:
-        int, str: interrogator identifier code that triggered the reply, and
-        reservation type made by the interrogator
-    """
-    msgbin = common.hex2bin(msg)
-    iis = common.bin2int(msgbin[13:17])
-    ids = common.bin2int(msgbin[17:19])
-    if ids == 0:
-        ids_text = None
-    if ids == 1:
-        ids_text = "Comm-B interrogator identifier code"
-    if ids == 2:
-        ids_text = "Comm-C interrogator identifier code"
-    if ids == 3:
-        ids_text = "Comm-D interrogator identifier code"
-    return iis, ids, ids_text
-
-
-@_checkdf
-def altitude(msg: str) -> None | int:
-    """Decode altitude.
-
-    Args:
-        msg (String): 14 hexdigits string
-
-    Returns:
-        int: altitude in ft
-
-    """
-    return common.altcode(msg)
-
-
-@_checkdf
-def identity(msg: str) -> str:
-    """Decode squawk code.
-
-    Args:
-        msg (String): 14 hexdigits string
-
-    Returns:
-        string: squawk code
-
-    """
-    return common.idcode(msg)

pyModeS/decoder/uncertainty.py

@@ -1,16 +1,8 @@
 """Uncertainty parameters.
 
+See source code at: https://github.com/junzis/pyModeS/blob/master/pyModeS/decoder/uncertainty.py
 """
 
-from __future__ import annotations
-
-import sys
-
-if sys.version_info < (3, 8):
-    from typing_extensions import TypedDict
-else:
-    from typing import TypedDict
-
 NA = None
 
 TC_NUCp_lookup = {
@@ -34,7 +26,7 @@ TC_NUCp_lookup = {
     22: 0,
 }
 
-TC_NICv1_lookup: dict[int, int | dict[int, int]] = {
+TC_NICv1_lookup = {
     5: 11,
     6: 10,
     7: 9,
@@ -54,7 +46,7 @@ TC_NICv1_lookup: dict[int, int | dict[int, int]] = {
     22: 0,
 }
 
-TC_NICv2_lookup: dict[int, int | dict[int, int]] = {
+TC_NICv2_lookup = {
     5: 11,
     6: 10,
     7: {2: 9, 0: 8},
@@ -75,13 +67,7 @@ TC_NICv2_lookup: dict[int, int | dict[int, int]] = {
 }
 
 
-class NUCpEntry(TypedDict):
+NUCp = {
-    HPL: None | float
-    RCu: None | int
-    RCv: None | int
-
-
-NUCp: dict[int, NUCpEntry] = {
     9: {"HPL": 7.5, "RCu": 3, "RCv": 4},
     8: {"HPL": 25, "RCu": 10, "RCv": 15},
     7: {"HPL": 185, "RCu": 93, "RCv": NA},
@@ -94,13 +80,7 @@ NUCp: dict[int, NUCpEntry] = {
     0: {"HPL": NA, "RCu": NA, "RCv": NA},
 }
 
-
+NUCv = {
-class NUCvEntry(TypedDict):
-    HVE: None | float
-    VVE: None | float
-
-
-NUCv: dict[int, NUCvEntry] = {
     0: {"HVE": NA, "VVE": NA},
     1: {"HVE": 10, "VVE": 15.2},
     2: {"HVE": 3, "VVE": 4.5},
@@ -108,13 +88,7 @@ NUCv: dict[int, NUCvEntry] = {
     4: {"HVE": 0.3, "VVE": 0.46},
 }
 
-
+NACp = {
-class NACpEntry(TypedDict):
-    EPU: None | int
-    VEPU: None | int
-
-
-NACp: dict[int, NACpEntry] = {
     11: {"EPU": 3, "VEPU": 4},
     10: {"EPU": 10, "VEPU": 15},
     9: {"EPU": 30, "VEPU": 45},
@@ -129,13 +103,7 @@ NACp: dict[int, NACpEntry] = {
     0: {"EPU": NA, "VEPU": NA},
 }
 
-
+NACv = {
-class NACvEntry(TypedDict):
-    HFOMr: None | float
-    VFOMr: None | float
-
-
-NACv: dict[int, NACvEntry] = {
     0: {"HFOMr": NA, "VFOMr": NA},
     1: {"HFOMr": 10, "VFOMr": 15.2},
     2: {"HFOMr": 3, "VFOMr": 4.5},
@@ -143,13 +111,7 @@ NACv: dict[int, NACvEntry] = {
     4: {"HFOMr": 0.3, "VFOMr": 0.46},
 }
 
-
+SIL = {
-class SILEntry(TypedDict):
-    PE_RCu: None | float
-    PE_VPL: None | float
-
-
-SIL: dict[int, SILEntry] = {
     3: {"PE_RCu": 1e-7, "PE_VPL": 2e-7},
     2: {"PE_RCu": 1e-5, "PE_VPL": 1e-5},
     1: {"PE_RCu": 1e-3, "PE_VPL": 1e-3},
@@ -157,12 +119,7 @@ SIL: dict[int, SILEntry] = {
 }
 
 
-class NICv1Entry(TypedDict):
+NICv1 = {
-    Rc: None | float
-    VPL: None | float
-
-
-NICv1: dict[int, dict[int, NICv1Entry]] = {
     # NIC is used as the index at second Level
     11: {0: {"Rc": 7.5, "VPL": 11}},
     10: {0: {"Rc": 25, "VPL": 37.5}},
@@ -178,12 +135,7 @@ NICv1: dict[int, dict[int, NICv1Entry]] = {
     0: {0: {"Rc": NA, "VPL": NA}},
 }
 
-
+NICv2 = {
-class NICv2Entry(TypedDict):
-    Rc: None | float
-
-
-NICv2: dict[int, dict[int, NICv2Entry]] = {
     # Decimal value of [NICa NICb/NICc] is used as the index at second Level
     11: {0: {"Rc": 7.5}},
     10: {0: {"Rc": 25}},

pyModeS/decoder/uplink.py

@@ -1,223 +0,0 @@
-from typing import Optional
-from .. import common
-from textwrap import wrap
-
-
-def uplink_icao(msg: str) -> str:
-    "Calculate the ICAO address from a Mode-S interrogation (uplink message)"
-    p_gen = 0xFFFA0480 << ((len(msg) - 14) * 4)
-    data = int(msg[:-6], 16)
-    PA = int(msg[-6:], 16)
-    ad = 0
-    topbit = 0b1 << (len(msg) * 4 - 25)
-    for j in range(0, len(msg) * 4, 1):
-        if data & topbit:
-            data ^= p_gen
-        data = (data << 1) + ((PA >> 23) & 1)
-        PA = PA << 1
-        if j > (len(msg) * 4 - 26):
-            ad = ad + ((data >> (len(msg) * 4 - 25)) & 1)
-            ad = ad << 1
-    return "%06X" % (ad >> 2)
-
-
-def uf(msg: str) -> int:
-    """Decode Uplink Format value, bits 1 to 5."""
-    ufbin = common.hex2bin(msg[:2])
-    return min(common.bin2int(ufbin[0:5]), 24)
-
-
-def bds(msg: str) -> Optional[str]:
-    "Decode requested BDS register from selective (Roll Call) interrogation."
-    UF = uf(msg)
-    msgbin = common.hex2bin(msg)
-    msgbin_split = wrap(msgbin, 8)
-    mbytes = list(map(common.bin2int, msgbin_split))
-
-    if UF in {4, 5, 20, 21}:
-
-        di = mbytes[1] & 0x7  # DI - Designator Identification
-        RR = mbytes[1] >> 3 & 0x1F
-        if RR > 15:
-            BDS1 = RR - 16
-            if di == 7:
-                RRS = mbytes[2] & 0x0F
-                BDS2 = RRS
-            elif di == 3:
-                RRS = ((mbytes[2] & 0x1) << 3) | ((mbytes[3] & 0xE0) >> 5)
-                BDS2 = RRS
-            else:
-                # for other values of DI, the BDS2 is assumed 0
-                # (as per ICAO Annex 10 Vol IV)
-                BDS2 = 0
-
-            return str(format(BDS1,"X")) + str(format(BDS2,"X"))
-        else:
-            return None
-    else:
-        return None
-
-
-def pr(msg: str) -> Optional[int]:
-    """Decode PR (probability of reply) field from All Call interrogation.
-    Interpretation:
-    0 signifies reply with probability of 1
-    1 signifies reply with probability of 1/2
-    2 signifies reply with probability of 1/4
-    3 signifies reply with probability of 1/8
-    4 signifies reply with probability of 1/16
-    5, 6, 7 not assigned
-    8 signifies disregard lockout, reply with probability of 1
-    9 signifies disregard lockout, reply with probability of 1/2
-    10 signifies disregard lockout, reply with probability of 1/4
-    11 signifies disregard lockout, reply with probability of 1/8
-    12 signifies disregard lockout, reply with probability of 1/16
-    13, 14, 15 not assigned.
-    """
-    msgbin = common.hex2bin(msg)
-    msgbin_split = wrap(msgbin, 8)
-    mbytes = list(map(common.bin2int, msgbin_split))
-    if uf(msg) == 11:
-        return ((mbytes[0] & 0x7) << 1) | ((mbytes[1] & 0x80) >> 7)
-    else:
-        return None
-
-
-def ic(msg: str) -> Optional[str]:
-    """Decode IC (interrogator code) from a ground-based interrogation."""
-
-    UF = uf(msg)
-    msgbin = common.hex2bin(msg)
-    msgbin_split = wrap(msgbin, 8)
-    mbytes = list(map(common.bin2int, msgbin_split))
-    IC = None
-    if UF == 11:
-
-        codeLabel = mbytes[1] & 0x7
-        icField = (mbytes[1] >> 3) & 0xF
-
-        # Store the Interogator Code
-        ic_switcher = {
-            0: "II" + str(icField),
-            1: "SI" + str(icField),
-            2: "SI" + str(icField + 16),
-            3: "SI" + str(icField + 32),
-            4: "SI" + str(icField + 48),
-        }
-        IC = ic_switcher.get(codeLabel, "")
-
-    if UF in {4, 5, 20, 21}:
-        di = mbytes[1] & 0x7
-        RR = mbytes[1] >> 3 & 0x1F
-        if RR > 15:
-            BDS1 = RR - 16  # noqa: F841
-        if di == 0 or di == 1 or di == 7:
-            # II
-            II = (mbytes[2] >> 4) & 0xF
-            IC = "II" + str(II)
-        elif di == 3:
-            # SI
-            SI = (mbytes[2] >> 2) & 0x3F
-            IC = "SI" + str(SI)
-    return IC
-
-
-def lockout(msg):
-    """Decode the lockout command from selective (Roll Call) interrogation."""
-    msgbin = common.hex2bin(msg)
-    msgbin_split = wrap(msgbin, 8)
-    mbytes = list(map(common.bin2int, msgbin_split))
-
-    if uf(msg) in {4, 5, 20, 21}:
-        lockout = False
-        di = mbytes[1] & 0x7
-        if di == 7:
-            # LOS
-            if ((mbytes[3] & 0x40) >> 6) == 1:
-                lockout = True
-        elif di == 3:
-            # LSS
-            if ((mbytes[2] & 0x2) >> 1) == 1:
-                lockout = True
-        return lockout
-    else:
-        return None
-
-
-def uplink_fields(msg):
-    """Decode individual fields of a ground-based interrogation."""
-    msgbin = common.hex2bin(msg)
-    msgbin_split = wrap(msgbin, 8)
-    mbytes = list(map(common.bin2int, msgbin_split))
-    PR = ""
-    IC = ""
-    lockout = False
-    di = ""
-    RR = ""
-    RRS = ""
-    BDS = ""
-    if uf(msg) == 11:
-
-        # Probability of Reply decoding
-
-        PR = ((mbytes[0] & 0x7) << 1) | ((mbytes[1] & 0x80) >> 7)
-
-        #  Get cl and ic bit fields from the data
-        #  Decode the SI or II interrogator code
-        codeLabel = mbytes[1] & 0x7
-        icField = (mbytes[1] >> 3) & 0xF
-
-        # Store the Interogator Code
-        ic_switcher = {
-            0: "II" + str(icField),
-            1: "SI" + str(icField),
-            2: "SI" + str(icField + 16),
-            3: "SI" + str(icField + 32),
-            4: "SI" + str(icField + 48),
-        }
-        IC = ic_switcher.get(codeLabel, "")
-
-    if uf(msg) in {4, 5, 20, 21}:
-        # Decode the DI and get the lockout information conveniently
-        # (LSS or LOS)
-
-        # DI - Designator Identification
-        di = mbytes[1] & 0x7
-        RR = mbytes[1] >> 3 & 0x1F
-        if RR > 15:
-            BDS1 = RR - 16
-            BDS2 = 0
-        if di == 0 or di == 1:
-            # II
-            II = (mbytes[2] >> 4) & 0xF
-            IC = "II" + str(II)
-        elif di == 7:
-            # LOS
-            if ((mbytes[3] & 0x40) >> 6) == 1:
-                lockout = True
-            # II
-            II = (mbytes[2] >> 4) & 0xF
-            IC = "II" + str(II)
-            RRS = mbytes[2] & 0x0F
-            BDS2 = RRS
-        elif di == 3:
-            # LSS
-            if ((mbytes[2] & 0x2) >> 1) == 1:
-                lockout = True
-            # SI
-            SI = (mbytes[2] >> 2) & 0x3F
-            IC = "SI" + str(SI)
-            RRS = ((mbytes[2] & 0x1) << 3) | ((mbytes[3] & 0xE0) >> 5)
-            BDS2 = RRS
-        if RR > 15:
-            BDS = str(format(BDS1,"X")) + str(format(BDS2,"X"))
-            
-    return {
-        "DI": di,
-        "IC": IC,
-        "LOS": lockout,
-        "PR": PR,
-        "RR": RR,
-        "RRS": RRS,
-        "BDS": BDS,
-    }

pyModeS/extra/__init__.py

@@ -0,0 +1 @@
+from __future__ import absolute_import, print_function, division

pyModeS/extra/aero.py

@@ -9,15 +9,15 @@ International Standard Atmosphere
 
     p,rho,T = atmos(H)    # atmos as function of geopotential altitude H [m]
     a = vsound(H)         # speed of sound [m/s] as function of H[m]
-    p = pressure(H)       # calls atmos but returns only pressure [Pa]
+    p = pressure(H)       # calls atmos but retruns only pressure [Pa]
     T = temperature(H)    # calculates temperature [K]
-    rho = density(H)      # calls atmos but returns only pressure [Pa]
+    rho = density(H)      # calls atmos but retruns only pressure [Pa]
 
 Speed conversion at altitude H[m] in ISA
 ::
 
     Mach = tas2mach(Vtas,H)    # true airspeed (Vtas) to mach number conversion
-    Vtas = mach2tas(Mach,H)    # mach number to true airspeed (Vtas) conversion
+    Vtas = mach2tas(Mach,H)    # true airspeed (Vtas) to mach number conversion
     Vtas = eas2tas(Veas,H)     # equivalent airspeed to true airspeed, H in [m]
     Veas = tas2eas(Vtas,H)     # true airspeed to equivent airspeed, H in [m]
     Vtas = cas2tas(Vcas,H)     # Vcas  to Vtas conversion both m/s, H in [m]
@@ -35,18 +35,18 @@ ft = 0.3048  # ft -> m
 fpm = 0.00508  # ft/min -> m/s
 inch = 0.0254  # inch -> m
 sqft = 0.09290304  # 1 square foot
-nm = 1852  # nautical mile -> m
+nm = 1852.0  # nautical mile -> m
 lbs = 0.453592  # pound -> kg
 g0 = 9.80665  # m/s2, Sea level gravity constant
 R = 287.05287  # m2/(s2 x K), gas constant, sea level ISA
-p0 = 101325  # Pa, air pressure, sea level ISA
+p0 = 101325.0  # Pa, air pressure, sea level ISA
 rho0 = 1.225  # kg/m3, air density, sea level ISA
 T0 = 288.15  # K, temperature, sea level ISA
 gamma = 1.40  # cp/cv for air
 gamma1 = 0.2  # (gamma-1)/2 for air
 gamma2 = 3.5  # gamma/(gamma-1) for air
 beta = -0.0065  # [K/m] ISA temp gradient below tropopause
-r_earth = 6371000  # m, average earth radius
+r_earth = 6371000.0  # m, average earth radius
 a0 = 340.293988  # m/s, sea level speed of sound ISA, sqrt(gamma*R*T0)
 
 
@@ -94,8 +94,8 @@ def distance(lat1, lon1, lat2, lon2, H=0):
     """
 
     # phi = 90 - latitude
-    phi1 = np.radians(90 - lat1)
+    phi1 = np.radians(90.0 - lat1)
-    phi2 = np.radians(90 - lat2)
+    phi2 = np.radians(90.0 - lat2)
 
     # theta = longitude
     theta1 = np.radians(lon1)
@@ -158,16 +158,16 @@ def tas2eas(Vtas, H):
 def cas2tas(Vcas, H):
     """Calibrated Airspeed to True Airspeed"""
     p, rho, T = atmos(H)
-    qdyn = p0 * ((1 + rho0 * Vcas * Vcas / (7 * p0)) ** 3.5 - 1.0)
+    qdyn = p0 * ((1.0 + rho0 * Vcas * Vcas / (7.0 * p0)) ** 3.5 - 1.0)
-    Vtas = np.sqrt(7 * p / rho * ((1 + qdyn / p) ** (2 / 7.0) - 1.0))
+    Vtas = np.sqrt(7.0 * p / rho * ((1.0 + qdyn / p) ** (2.0 / 7.0) - 1.0))
     return Vtas
 
 
 def tas2cas(Vtas, H):
     """True Airspeed to Calibrated Airspeed"""
     p, rho, T = atmos(H)
-    qdyn = p * ((1 + rho * Vtas * Vtas / (7 * p)) ** 3.5 - 1.0)
+    qdyn = p * ((1.0 + rho * Vtas * Vtas / (7.0 * p)) ** 3.5 - 1.0)
-    Vcas = np.sqrt(7 * p0 / rho0 * ((qdyn / p0 + 1.0) ** (2 / 7.0) - 1.0))
+    Vcas = np.sqrt(7.0 * p0 / rho0 * ((qdyn / p0 + 1.0) ** (2.0 / 7.0) - 1.0))
     return Vcas
 
 

pyModeS/extra/rtlreader.py

@@ -1,120 +1,90 @@
-import time
-import traceback
 import numpy as np
 import pyModeS as pms
+from rtlsdr import RtlSdr
+import time
 
-try:
+modes_sample_rate = 2e6
-    import rtlsdr  # type: ignore
-except:
-    print("------------------------------------------------------------------------")
-    print("! Warning: pyrtlsdr not installed (required for using RTL-SDR devices) !")
-    print("------------------------------------------------------------------------")
-
-sampling_rate = 2e6
-smaples_per_microsec = 2
-
 modes_frequency = 1090e6
-buffer_size = 1024 * 200
+buffer_size = 1024 * 100
-read_size = 1024 * 100
+read_size = 1024 * 20
 
 pbits = 8
 fbits = 112
 preamble = [1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0]
+th_amp = 0.2  # signal amplitude threshold for 0 and 1 bit
 th_amp_diff = 0.8  # signal amplitude threshold difference between 0 and 1 bit
 
 
 class RtlReader(object):
     def __init__(self, **kwargs):
         super(RtlReader, self).__init__()
-        self.signal_buffer = []  # amplitude of the sample only
+        self.signal_buffer = []
-        self.sdr = rtlsdr.RtlSdr()
+        self.sdr = RtlSdr()
-        self.sdr.sample_rate = sampling_rate
+        self.sdr.sample_rate = modes_sample_rate
         self.sdr.center_freq = modes_frequency
         self.sdr.gain = "auto"
+        # sdr.freq_correction = 75
 
         self.debug = kwargs.get("debug", False)
         self.raw_pipe_in = None
         self.stop_flag = False
-        self.noise_floor = 1e6
-
-        self.exception_queue = None
-
-    def _calc_noise(self):
-        """Calculate noise floor"""
-        window = smaples_per_microsec * 100
-        total_len = len(self.signal_buffer)
-        means = (
-            np.array(self.signal_buffer[: total_len // window * window])
-            .reshape(-1, window)
-            .mean(axis=1)
-        )
-        return min(means)
 
     def _process_buffer(self):
-        """process raw IQ data in the buffer"""
-
-        # update noise floor
-        self.noise_floor = min(self._calc_noise(), self.noise_floor)
-
-        # set minimum signal amplitude
-        min_sig_amp = 3.162 * self.noise_floor  # 10 dB SNR
-
-        # Mode S messages
         messages = []
 
+        # signal_array = np.array(self.signal_buffer)
+        # pulses_array = np.where(np.array(self.signal_buffer) < th_amp, 0, 1)
+        # pulses = "".join(str(x) for x in pulses_array)
         buffer_length = len(self.signal_buffer)
 
         i = 0
         while i < buffer_length:
-            if self.signal_buffer[i] < min_sig_amp:
+            if self.signal_buffer[i] < th_amp:
                 i += 1
                 continue
 
+            # if pulses[i : i + pbits * 2] == preamble:
             if self._check_preamble(self.signal_buffer[i : i + pbits * 2]):
                 frame_start = i + pbits * 2
                 frame_end = i + pbits * 2 + (fbits + 1) * 2
                 frame_length = (fbits + 1) * 2
                 frame_pulses = self.signal_buffer[frame_start:frame_end]
 
-                threshold = max(frame_pulses) * 0.2
+                msgbin = ""
-
-                msgbin = []
                 for j in range(0, frame_length, 2):
                     p2 = frame_pulses[j : j + 2]
                     if len(p2) < 2:
                         break
 
-                    if p2[0] < threshold and p2[1] < threshold:
+                    if p2[0] < th_amp and p2[1] < th_amp:
                         break
                     elif p2[0] >= p2[1]:
-                        c = 1
+                        c = "1"
                     elif p2[0] < p2[1]:
-                        c = 0
+                        c = "0"
                     else:
-                        msgbin = []
+                        msgbin = ""
                         break
-
+                    msgbin += c
-                    msgbin.append(c)
 
                 # advance i with a jump
                 i = frame_start + j
 
                 if len(msgbin) > 0:
-                    msghex = pms.bin2hex("".join([str(i) for i in msgbin]))
+                    msghex = pms.bin2hex(msgbin)
                     if self._check_msg(msghex):
                         messages.append([msghex, time.time()])
                     if self.debug:
                         self._debug_msg(msghex)
 
-            # elif i > buffer_length - 500:
+            elif i > buffer_length - 500:
-            #     # save some for next process
+                # save some for next process
-            #     break
+                break
             else:
                 i += 1
 
-        # reset the buffer
+        # keep reminder of buffer for next iteration
         self.signal_buffer = self.signal_buffer[i:]
-
         return messages
 
     def _check_preamble(self, pulses):
@@ -152,8 +122,10 @@ class RtlReader(object):
             pass
 
     def _read_callback(self, data, rtlsdr_obj):
+        # scaling signal (imporatant)
         amp = np.absolute(data)
-        self.signal_buffer.extend(amp.tolist())
+        amp_norm = np.interp(amp, (amp.min(), amp.max()), (0, 1))
+        self.signal_buffer.extend(amp_norm.tolist())
 
         if len(self.signal_buffer) >= buffer_size:
             messages = self._process_buffer()
@@ -166,25 +138,18 @@ class RtlReader(object):
             pass
 
     def stop(self, *args, **kwargs):
-        self.sdr.close()
+        self.sdr.cancel_read_async()
 
-    def run(self, raw_pipe_in=None, stop_flag=None, exception_queue=None):
+    def run(self, raw_pipe_in=None, stop_flag=None):
         self.raw_pipe_in = raw_pipe_in
-        self.exception_queue = exception_queue
         self.stop_flag = stop_flag
+        self.sdr.read_samples_async(self._read_callback, read_size)
 
-        try:
+        # count = 1
-            # raise RuntimeError("test exception")
+        # while count < 1000:
-
+        #     count += 1
-            while True:
+        #     data = self.sdr.read_samples(read_size)
-                data = self.sdr.read_samples(read_size)
+        #     self._read_callback(data, None)
-                self._read_callback(data, None)
-
-        except Exception as e:
-            tb = traceback.format_exc()
-            if self.exception_queue is not None:
-                self.exception_queue.put(tb)
-            raise e
 
 
 if __name__ == "__main__":

pyModeS/extra/tcpclient.py

@@ -1,5 +1,6 @@
 """Stream beast raw data from a TCP server, convert to mode-s messages."""
 
+from __future__ import print_function, division
 import os
 import sys
 import time
@@ -7,6 +8,11 @@ import pyModeS as pms
 import traceback
 import zmq
 
+if sys.version_info > (3, 0):
+    PY_VERSION = 3
+else:
+    PY_VERSION = 2
+
 
 class TcpClient(object):
     def __init__(self, host, port, datatype):
@@ -23,8 +29,6 @@ class TcpClient(object):
         self.raw_pipe_in = None
         self.stop_flag = False
 
-        self.exception_queue = None
-
     def connect(self):
         self.socket = zmq.Context().socket(zmq.STREAM)
         self.socket.setsockopt(zmq.LINGER, 0)
@@ -32,7 +36,7 @@ class TcpClient(object):
         self.socket.connect("tcp://%s:%s" % (self.host, self.port))
 
     def stop(self):
-        self.socket.close()
+        self.socket.disconnect()
 
     def read_raw_buffer(self):
         """ Read raw ADS-B data type.
@@ -166,7 +170,7 @@ class TcpClient(object):
               Start character '$'
 
             MS field - Payload
-            Position 1 through 14:
+            Postion 1 through 14:
               14 bytes = 112 bits
               Mode-S payload
               In case of DF types that only carry 7 bytes of information
@@ -250,9 +254,8 @@ class TcpClient(object):
         for msg, t in messages:
             print("%15.9f %s" % (t, msg))
 
-    def run(self, raw_pipe_in=None, stop_flag=None, exception_queue=None):
+    def run(self, raw_pipe_in=None, stop_flag=None):
         self.raw_pipe_in = raw_pipe_in
-        self.exception_queue = exception_queue
         self.stop_flag = stop_flag
         self.connect()
 
@@ -260,9 +263,17 @@ class TcpClient(object):
             try:
                 received = [i for i in self.socket.recv(4096)]
 
+                if PY_VERSION == 2:
+                    received = [ord(i) for i in received]
+
                 self.buffer.extend(received)
                 # print(''.join(x.encode('hex') for x in self.buffer))
 
+                # process self.buffer when it is longer enough
+                # if len(self.buffer) < 2048:
+                #     continue
+                # -- Removed!! Cause delay in low data rate scenario --
+
                 if self.datatype == "beast":
                     messages = self.read_beast_buffer()
                 elif self.datatype == "raw":
@@ -275,15 +286,22 @@ class TcpClient(object):
                 else:
                     self.handle_messages(messages)
 
-                # raise RuntimeError("test exception")
-
-            except zmq.error.Again:
-                continue
             except Exception as e:
-                tb = traceback.format_exc()
+                # Provides the user an option to supply the environment
-                if self.exception_queue is not None:
+                # variable PYMODES_DEBUG to halt the execution
-                    self.exception_queue.put(tb)
+                # for debugging purposes
-                raise e
+                debug_intent = os.environ.get("PYMODES_DEBUG", "false")
+                if debug_intent.lower() == "true":
+                    traceback.print_exc()
+                    sys.exit()
+                else:
+                    print("Unexpected Error:", e)
+
+                try:
+                    sock = self.connect()
+                    time.sleep(1)
+                except Exception as e:
+                    print("Unexpected Error:", e)
 
 
 if __name__ == "__main__":
@@ -292,7 +310,4 @@ if __name__ == "__main__":
     port = int(sys.argv[2])
     datatype = sys.argv[3]
     client = TcpClient(host=host, port=port, datatype=datatype)
-    try:
+    client.run()
-        client.run()
-    finally:
-        client.stop()

pyModeS/streamer/decode.py

@@ -1,6 +1,6 @@
+from __future__ import absolute_import, print_function, division
 import os
 import time
-import traceback
 import datetime
 import csv
 import pyModeS as pms
@@ -27,7 +27,7 @@ class Decode:
             self.dumpto = None
 
     def process_raw(self, adsb_ts, adsb_msg, commb_ts, commb_msg, tnow=None):
-        """process a chunk of adsb and commb messages received in the same
+        """process a chunk of adsb and commb messages recieved in the same
         time period.
         """
         if tnow is None:
@@ -232,13 +232,10 @@ class Decode:
                     self.acs[icao]["t60"] = t
                 if ias60:
                     self.acs[icao]["ias"] = ias60
-                    output_buffer.append([t, icao, "ias60", ias60])
                 if hdg60:
                     self.acs[icao]["hdg"] = hdg60
-                    output_buffer.append([t, icao, "hdg60", hdg60])
                 if mach60:
                     self.acs[icao]["mach"] = mach60
-                    output_buffer.append([t, icao, "mach60", mach60])
 
                 if roc60baro:
                     output_buffer.append([t, icao, "roc60baro", roc60baro])
@@ -262,31 +259,26 @@ class Decode:
         return
 
     def get_aircraft(self):
-        """all aircraft that are stored in memory"""
+        """all aircraft that are stored in memeory"""
         acs = self.acs
         return acs
 
-    def run(self, raw_pipe_out, ac_pipe_in, exception_queue):
+    def run(self, raw_pipe_out, ac_pipe_in):
         local_buffer = []
         while True:
-            try:
+            while raw_pipe_out.poll():
-                while raw_pipe_out.poll():
+                data = raw_pipe_out.recv()
-                    data = raw_pipe_out.recv()
+                local_buffer.append(data)
-                    local_buffer.append(data)
 
-                for data in local_buffer:
+            for data in local_buffer:
-                    self.process_raw(
+                self.process_raw(
-                        data["adsb_ts"],
+                    data["adsb_ts"],
-                        data["adsb_msg"],
+                    data["adsb_msg"],
-                        data["commb_ts"],
+                    data["commb_ts"],
-                        data["commb_msg"],
+                    data["commb_msg"],
-                    )
+                )
-                local_buffer = []
+            local_buffer = []
 
-                acs = self.get_aircraft()
+            acs = self.get_aircraft()
-                ac_pipe_in.send(acs)
+            ac_pipe_in.send(acs)
-                time.sleep(0.001)
+            time.sleep(0.001)
-
-            except Exception as e:
-                tb = traceback.format_exc()
-                exception_queue.put((e, tb))

pyModeS/streamer/modeslive

@@ -1,8 +1,8 @@
 #!/usr/bin/env python
 
+from __future__ import print_function, division
 import os
 import sys
-import time
 import argparse
 import curses
 import signal
@@ -12,6 +12,10 @@ from pyModeS.streamer.screen import Screen
 from pyModeS.streamer.source import NetSource, RtlSdrSource
 
 
+# redirect all stdout to null, avoiding messing up with the screen
+sys.stdout = open(os.devnull, "w")
+
+
 support_rawtypes = ["raw", "beast", "skysense"]
 
 parser = argparse.ArgumentParser()
@@ -23,9 +27,8 @@ parser.add_argument(
 )
 parser.add_argument(
     "--connect",
-    help="Define server, port and data type. Supported data types are: {}".format(
+    help="Define server, port and data type. Supported data types are: %s"
-        support_rawtypes
+    % support_rawtypes,
-    ),
     nargs=3,
     metavar=("SERVER", "PORT", "DATATYPE"),
     default=None,
@@ -68,7 +71,7 @@ elif SOURCE == "net":
     else:
         SERVER, PORT, DATATYPE = args.connect
         if DATATYPE not in support_rawtypes:
-            print("Data type not supported, available ones are %s" % support_rawtypes)
+            print("Data type not supported, avaiable ones are %s" % support_rawtypes)
 
 else:
     print('Source must be "rtlsdr" or "net".')
@@ -84,13 +87,13 @@ if DUMPTO is not None:
         sys.exit(1)
 
 
-# redirect all stdout to null, avoiding messing up with the screen
+# raw_event = multiprocessing.Event()
-sys.stdout = open(os.devnull, "w")
+# ac_event = multiprocessing.Event()
-
+# raw_queue = multiprocessing.Queue()
+# ac_queue = multiprocessing.Queue()
 
 raw_pipe_in, raw_pipe_out = multiprocessing.Pipe()
 ac_pipe_in, ac_pipe_out = multiprocessing.Pipe()
-exception_queue = multiprocessing.Queue()
 stop_flag = multiprocessing.Value("b", False)
 
 if SOURCE == "net":
@@ -99,38 +102,29 @@ elif SOURCE == "rtlsdr":
     source = RtlSdrSource()
 
 
-recv_process = multiprocessing.Process(
+recv_process = multiprocessing.Process(target=source.run, args=(raw_pipe_in, stop_flag))
-    target=source.run, args=(raw_pipe_in, stop_flag, exception_queue)
-)
 
 
 decode = Decode(latlon=LATLON, dumpto=DUMPTO)
 decode_process = multiprocessing.Process(
-    target=decode.run, args=(raw_pipe_out, ac_pipe_in, exception_queue)
+    target=decode.run, args=(raw_pipe_out, ac_pipe_in)
 )
 
 screen = Screen(uncertainty=UNCERTAINTY)
-screen_process = multiprocessing.Process(
+screen_process = multiprocessing.Process(target=screen.run, args=(ac_pipe_out,))
-    target=screen.run, args=(ac_pipe_out, exception_queue)
-)
 
 
-def shutdown():
+def closeall(signal, frame):
+    print("KeyboardInterrupt (ID: {}). Cleaning up...".format(signal))
     stop_flag.value = True
     curses.endwin()
-    sys.stdout = sys.__stdout__
     recv_process.terminate()
     decode_process.terminate()
     screen_process.terminate()
     recv_process.join()
     decode_process.join()
     screen_process.join()
-
+    exit(0)
-
-def closeall(signal, frame):
-    print("KeyboardInterrupt (ID: {}). Cleaning up...".format(signal))
-    shutdown()
-    sys.exit(0)
 
 
 signal.signal(signal.SIGINT, closeall)
@@ -138,19 +132,3 @@ signal.signal(signal.SIGINT, closeall)
 recv_process.start()
 decode_process.start()
 screen_process.start()
-
-
-while True:
-    if (
-        (not recv_process.is_alive())
-        or (not decode_process.is_alive())
-        or (not screen_process.is_alive())
-    ):
-        shutdown()
-        while not exception_queue.empty():
-            trackback = exception_queue.get()
-            print(trackback)
-
-        sys.exit(1)
-
-    time.sleep(0.01)

pyModeS/streamer/screen.py

@@ -1,8 +1,8 @@
+from __future__ import print_function, division
 import curses
 import numpy as np
 import time
 import threading
-import traceback
 
 COLUMNS = [
     ("call", 10),
@@ -187,32 +187,24 @@ class Screen(object):
                 self.screen.refresh()
                 self.draw_frame()
 
-    def run(self, ac_pipe_out, exception_queue):
+    def run(self, ac_pipe_out):
         local_buffer = []
         key_thread = threading.Thread(target=self.kye_handling)
-        key_thread.daemon = True
         key_thread.start()
 
         while True:
+            while ac_pipe_out.poll():
+                acs = ac_pipe_out.recv()
+                local_buffer.append(acs)
+
+            for acs in local_buffer:
+                self.update_ac(acs)
+
+            local_buffer = []
+
             try:
-                # raise RuntimeError("test exception")
-
-                while ac_pipe_out.poll():
-                    acs = ac_pipe_out.recv()
-                    local_buffer.append(acs)
-
-                for acs in local_buffer:
-                    self.update_ac(acs)
-
-                local_buffer = []
-
                 self.update()
-            except curses.error:
+            except:
                 pass
-            except Exception as e:
-                tb = traceback.format_exc()
-                exception_queue.put(tb)
-                time.sleep(0.1)
-                raise e
 
             time.sleep(0.001)

setup.cfg

@@ -1,3 +0,0 @@
-# https://github.com/embray/setup.cfg
-[metadata]
-license_file = LICENSE

setup.py

@@ -4,18 +4,24 @@ See:
 https://packaging.python.org/en/latest/distributing.html
 https://github.com/pypa/sampleproject
 
-Steps for deploying a new version:
+Steps for deploying a new verison:
 1. Increase the version number
 2. remove the old deployment under [dist] and [build] folder
 3. run: python setup.py sdist
+   run: python setup.py bdist_wheel --universal
 4. twine upload dist/*
 """
 
-import sys
-
 # Always prefer setuptools over distutils
 from setuptools import setup, find_packages
 
+# Compile some parts
+from setuptools.extension import Extension
+from Cython.Build import cythonize
+
+extensions = [Extension("pyModeS.decoder.c_common", ["pyModeS/decoder/c_common.pyx"])]
+
+
 # To use a consistent encoding
 from codecs import open
 from os import path
@@ -26,76 +32,78 @@ here = path.abspath(path.dirname(__file__))
 with open(path.join(here, "README.rst"), encoding="utf-8") as f:
     long_description = f.read()
 
-
+setup(
-details = dict(
     name="pyModeS",
-    version="2.11",
+    # Versions should comply with PEP440.  For a discussion on single-sourcing
+    # the version across setup.py and the project code, see
+    # https://packaging.python.org/en/latest/single_source_version.html
+    version="2.4",
     description="Python Mode-S and ADS-B Decoder",
     long_description=long_description,
+    # The project's main homepage.
     url="https://github.com/junzis/pyModeS",
+    # Author details
     author="Junzi Sun",
     author_email="j.sun-1@tudelft.nl",
+    # Choose your license
     license="GNU GPL v3",
+    # See https://pypi.python.org/pypi?%3Aaction=list_classifiers
     classifiers=[
+        # How mature is this project? Common values are
+        #   3 - Alpha
+        #   4 - Beta
+        #   5 - Production/Stable
         "Development Status :: 4 - Beta",
+        # Indicate who your project is intended for
         "Intended Audience :: Developers",
         "Topic :: Software Development :: Libraries",
+        # Pick your license as you wish (should match "license" above)
         "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+        # Specify the Python versions you support here. In particular, ensure
+        # that you indicate whether you support Python 2, Python 3 or both.
+        "Programming Language :: Python :: 2",
         "Programming Language :: Python :: 3",
     ],
+    ext_modules=cythonize(extensions),
+    # What does your project relate to?
     keywords="Mode-S ADS-B EHS ELS Comm-B",
+    # You can just specify the packages manually here if your project is
+    # simple. Or you can use find_packages().
     packages=find_packages(exclude=["contrib", "docs", "tests"]),
-    # typing_extensions are no longer necessary after Python 3.8 (TypedDict)
+    # Alternatively, if you want to distribute just a my_module.py, uncomment
-    install_requires=["numpy", "pyzmq", "typing_extensions"],
+    # this:
-    extras_require={"fast": ["Cython"]},
+    #   py_modules=["my_module"],
-    package_data={
+    # List run-time dependencies here.  These will be installed by pip when
-        "pyModeS": ["*.pyx", "*.pxd", "py.typed"],
+    # your project is installed. For an analysis of "install_requires" vs pip's
-        "pyModeS.decoder.flarm": ["*.pyx", "*.pxd", "*.pyi"],
+    # requirements files see:
-    },
+    # https://packaging.python.org/en/latest/requirements.html
+    install_requires=["numpy", "argparse", "pyzmq", "pyrtlsdr"],
+    # List additional groups of dependencies here (e.g. development
+    # dependencies). You can install these using the following syntax,
+    # for example:
+    # $ pip install -e .[dev,test]
+    # extras_require={
+    #     'dev': ['check-manifest'],
+    #     'test': ['coverage'],
+    # },
+    # If there are data files included in your packages that need to be
+    # installed, specify them here.  If using Python 2.6 or less, then these
+    # have to be included in MANIFEST.in as well.
+    # package_data={
+    #     'sample': ['package_data.dat'],
+    # },
+    # Although 'package_data' is the preferred approach, in some case you may
+    # need to place data files outside of your packages. See:
+    # http://docs.python.org/3.4/distutils/setupscript.html#installing-additional-files # noqa
+    # In this case, 'data_file' will be installed into '<sys.prefix>/my_data'
+    # data_files=[('my_data', ['data/data_file'])],
+    # To provide executable scripts, use entry points in preference to the
+    # "scripts" keyword. Entry points provide cross-platform support and allow
+    # pip to create the appropriate form of executable for the target platform.
+    # entry_points={
+    #     'console_scripts': [
+    #         'sample=sample:main',
+    #     ],
+    # },
     scripts=["pyModeS/streamer/modeslive"],
 )
-
-try:
-    from distutils.core import Extension
-    from Cython.Build import cythonize
-
-    compile_args = []
-    include_dirs = ["pyModeS/decoder/flarm"]
-
-    if sys.platform == "linux":
-        compile_args += [
-            "-march=native",
-            "-O3",
-            "-msse",
-            "-msse2",
-            "-mfma",
-            "-mfpmath=sse",
-            "-Wno-pointer-sign",
-        ]
-
-    extensions = [
-        Extension("pyModeS.c_common", ["pyModeS/c_common.pyx"]),
-        Extension(
-            "pyModeS.decoder.flarm.decode",
-            [
-                "pyModeS/decoder/flarm/decode.pyx",
-                "pyModeS/decoder/flarm/core.c",
-            ],
-            extra_compile_args=compile_args,
-            include_dirs=include_dirs,
-        ),
-    ]
-
-    setup(
-        **dict(
-            details,
-            ext_modules=cythonize(
-                extensions,
-                include_path=include_dirs,
-                compiler_directives={"binding": True, "language_level": 3},
-            ),
-        )
-    )
-
-except ImportError:
-    setup(**details)

tests/sample_run_adsb.py

@@ -1,7 +1,11 @@
-import csv
+import sys
 import time
+import csv
 
-from pyModeS.decoder import adsb
+if len(sys.argv) > 1 and sys.argv[1] == "cython":
+    from pyModeS.c_decoder import adsb
+else:
+    from pyModeS.decoder import adsb
 
 print("===== Decode ADS-B sample data=====")
 

tests/sample_run_commb.py

@@ -1,3 +1,4 @@
+from __future__ import print_function
 from pyModeS import commb, common, bds
 
 # === Decode sample data file ===
@@ -46,7 +47,7 @@ def bds_info(BDS, m):
         )
 
     else:
-        info = []
+        info = None
 
     return info
 
@@ -87,5 +88,5 @@ def commb_decode_all(df, n=None):
 
 
 if __name__ == "__main__":
-    commb_decode_all(df=20, n=500)
+    commb_decode_all(df=20, n=100)
-    commb_decode_all(df=21, n=500)
+    commb_decode_all(df=21, n=100)

tests/test_acas.py

@@ -1,40 +0,0 @@
-import pyModeS as pms
-
-msgs = [
-    "80E1983958C392E8710C642D0BAD",
-    "8609F8E19E90653083FDE096BE26",
-    "80011B41F40017D0000012E06B45",
-    "808182365813667446EB715E253D",
-    "80E1953058AB029BE8F4E60D989E",
-    "8667ECFA8FE06B30E59A124D5AEF",
-    "80030AA000042C0AD05D6205DB2C",
-    "8631A80000373C463B6E7A00008B",
-    "80E19131588B146108DE703F3C47",
-    "825CC4A0001595C4600030A40000",
-    "808182365813667438EB710EB6D8",
-    "80A18393581D3655E90354A664B2",
-    "8081823658136309B4F22BCB5F8D",
-    "80E1953058AB06516E8602756DD8",
-    "80E1991058C9063AB6A3E4744DC3",
-    "8073EC91840AFCED8F300BE765C5",
-    "8571F54AA814BF8130066A19A31D",
-    "864070E1990D3B1E78048BAE6987",
-    "80E1991058C9063AB6A3E4744DC3",
-    "80818298581581F7CAF8C3C1EEA4",
-    "80004E98BC90000FF01010951298",
-    "8526D57E4D963C92CDEE1B6C7C49",
-    "802A613C93F65A7FF803A51B5ADB",
-    "85B6C54279B67BE2A0001998FFDA",
-    "851944F15881648338D1AF4B7A27",
-    "8321014858208000787905B0E800",
-    "866DD078EDEBD330404FFFAE9BA5",
-    "80E196905AB503260E835D849E35",
-]
-
-for msg in msgs:
-    print("-" * 80)
-    print(msg)
-    print("ARA", pms.acas.ara(msg))
-    print("RAC", pms.acas.rac(msg))
-    print("MTE", pms.acas.mte(msg))
-    print("RAT", pms.acas.rat(msg))