dronecot 1.0.0b5__py3-none-any.whl

dronecot/__init__.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Copyright Sensors & Signals LLC https://www.snstac.com
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Drone Open Remote ID to TAK Gateway.
+
+:source: <https://github.com/snstac/dronecot>
+"""
+
+__version__ = "1.0.0-beta5"
+__author__ = "Greg Albrecht <gba@snstac.com>"
+__copyright__ = "Copyright Sensors & Signals LLC https://www.snstac.com"
+__license__ = "Apache License, Version 2.0"
+
+from .constants import (  # NOQA
+    DEFAULT_MQTT_BROKER,
+    DEFAULT_MQTT_PORT,
+    DEFAULT_MQTT_TOPIC,
+    DEFAULT_GPS_INFO_CMD,
+)
+from .functions import (  # NOQA
+    xml_to_cot,
+    create_tasks,
+)
+from .classes import MQTTWorker, RIDWorker  # NOQA
+from .open_drone_id import ODIDValidBlocks, decode_valid_blocks, parse_payload  # NOQA

dronecot/classes.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Copyright Sensors & Signals LLC https://www.snstac.com
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""DroneCOT Class Definitions."""
+
+import base64
+import json
+
+from typing import Optional
+
+import asyncio_mqtt as aiomqtt
+from bitstruct import *
+import lzma
+
+import pytak
+import dronecot
+
+__author__ = "Greg Albrecht <gba@snstac.com>"
+__copyright__ = "Copyright Sensors & Signals LLC https://www.snstac.com"
+__license__ = "Apache License, Version 2.0"
+
+
+class MQTTWorker(pytak.QueueWorker):
+    """Queue Worker for MQTT."""
+
+    async def parse_message(self, message):
+        """Parse Open Drone ID message from MQTT."""
+        try:
+            # not compressed
+            payload = message.payload.decode()
+            # remove newline (\n) char or \0 char as it will prevent decoding of json
+            if ord(payload[-1:]) == 0 or ord(payload[-1:]) == 10:
+                payload = payload[:-1]
+        except (UnicodeDecodeError, AttributeError):
+            # lzma compressed
+            payload = lzma.decompress(message.payload).decode()
+            # remove \0 char as it will prevent decoding of json
+            if ord(payload[-1:]) == 0:
+                payload = payload[:-1]
+
+        position = 0
+        while position != -1:
+            position = payload.find("}{")
+            if position == -1:
+                json_obj = json.loads(payload)
+            else:
+                message_payload = payload[0 : position + 1]
+                payload = payload[position + 1 :]
+                json_obj = json.loads(message_payload)
+
+            proto = json_obj.get("protocol")
+            if proto != 1.0:
+                return
+
+            if json_obj.get("data"):
+                await self.handle_sensor_data(json_obj)
+            elif json_obj.get("status"):
+                await self.handle_sensor_status(json_obj)
+
+    async def handle_sensor_data(self, message):
+        """Process decoded data from the sensor."""
+        data = message.get("data")
+        uasdata = data.get("UASdata")
+        if not uasdata:
+            return
+
+        uasdata = base64.b64decode(uasdata)
+
+        valid_blocks = dronecot.decode_valid_blocks(uasdata, dronecot.ODIDValidBlocks())
+        pl = dronecot.parse_payload(uasdata, valid_blocks)
+        await self.put_queue(pl)
+
+    async def handle_sensor_status(self, message):
+        """Process sensor status."""
+        status = message.get("status")
+        if not status:
+            return
+        await self.put_queue(message)
+
+    async def run(self, _=-1) -> None:
+        """Run this Thread, Reads from Pollers."""
+        self._logger.info("Run: MQTTWorker")
+
+        client_id = self.config.get("MQTT_CLIENT_ID", "dronecot")
+        topic = self.config.get("MQTT_TOPIC", dronecot.DEFAULT_MQTT_TOPIC)
+        broker = self.config.get("MQTT_BROKER", dronecot.DEFAULT_MQTT_BROKER)
+        port = self.config.get("MQTT_PORT", dronecot.DEFAULT_MQTT_PORT)
+        mqtt_username = self.config.get("MQTT_USERNAME")
+        mqtt_password = self.config.get("MQTT_PASSWORD")
+
+        async with aiomqtt.Client(
+            hostname=broker,
+            port=port,
+            username=mqtt_username,
+            password=mqtt_password,
+            client_id=client_id,
+        ) as client:
+            self._logger.info("Connected to MQTT Broker %s:%d/%s", broker, port, topic)
+            async with client.messages() as messages:
+                await client.subscribe(topic)
+                async for message in messages:
+                    await self.parse_message(message)
+
+
+class RIDWorker(pytak.QueueWorker):
+    """Queue Worker for RID."""
+
+    def __init__(self, queue, net_queue, config):
+        """Initialize this class."""
+        super().__init__(queue, config)
+        self.net_queue = net_queue
+        self.config = config
+
+    async def handle_data(self, data: dict) -> None:
+        """Handle Data from ADS-B receiver: Render to CoT, put on TX queue.
+
+        Parameters
+        ----------
+        data : `list[dict, ]`
+            List of craft data as key/value arrays.
+        """
+        # self._logger.info(data)
+        if "status" in data:
+            event = dronecot.xml_to_cot(data, self.config, "sensor_status_to_cot")
+            await self.put_queue(event)
+        else:
+            uas_event: Optional[bytes] = dronecot.xml_to_cot(
+                data, self.config, "rid_uas_to_cot_xml"
+            )
+            op_event: Optional[bytes] = dronecot.xml_to_cot(
+                data, self.config, "rid_op_to_cot_xml"
+            )
+            await self.put_queue(uas_event)
+            await self.put_queue(op_event)
+
+    async def run(self, _=-1) -> None:
+        """Run the main process loop."""
+        self._logger.info("Run: RIDWorker")
+
+        while 1:
+            data = await self.net_queue.get()
+            if not data:
+                # await asyncio.sleep(0.01)
+                continue
+
+            await self.handle_data(data)

dronecot/commands.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Copyright Sensors & Signals LLC https://www.snstac.com
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""PyTAK Command Line."""
+
+import pytak
+
+__author__ = "Greg Albrecht <gba@snstac.com>"
+__copyright__ = "Copyright Sensors & Signals LLC https://www.snstac.com"
+__license__ = "Apache License, Version 2.0"
+
+
+def main() -> None:
+    """Boilerplate main func."""
+    # PyTAK CLI tool boilerplate:
+    pytak.cli(__name__.split(".", maxsplit=1)[0])
+
+
+if __name__ == "__main__":
+    main()

dronecot/constants.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Copyright Sensors & Signals LLC https://www.snstac.com
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""DroneCOT Constants."""
+
+__author__ = "Greg Albrecht <gba@snstac.com>"
+__copyright__ = "Copyright Sensors & Signals LLC https://www.snstac.com"
+__license__ = "Apache License, Version 2.0"
+
+
+DEFAULT_MQTT_BROKER: str = "localhost"
+DEFAULT_MQTT_PORT: int = 1883
+DEFAULT_MQTT_TOPIC: str = "#"
+DEFAULT_GPS_INFO_CMD: str = "gpspipe --json -n 5"

dronecot/functions.py

@@ -0,0 +1,385 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Copyright Sensors & Signals LLC https://www.snstac.com
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""DroneCOT Functions."""
+
+import asyncio
+import json
+import os
+import xml.etree.ElementTree as ET
+
+from configparser import SectionProxy
+from typing import Optional, Set, Union
+
+import pytak
+import dronecot
+
+__author__ = "Greg Albrecht <gba@snstac.com>"
+__copyright__ = "Copyright Sensors & Signals LLC https://www.snstac.com"
+__license__ = "Apache License, Version 2.0"
+
+
+APP_NAME = "dronecot"
+
+
+def create_tasks(config: SectionProxy, clitool: pytak.CLITool) -> Set[pytak.Worker,]:
+    """Create specific coroutine task set for this application.
+
+    Parameters
+    ----------
+    config : `SectionProxy`
+        Configuration options & values.
+    clitool : `pytak.CLITool`
+        A PyTAK Worker class instance.
+
+    Returns
+    -------
+    `set`
+        Set of PyTAK Worker classes for this application.
+    """
+    tasks = set()
+
+    net_queue: asyncio.Queue = asyncio.Queue()
+
+    tasks.add(dronecot.MQTTWorker(net_queue, config))
+    tasks.add(dronecot.RIDWorker(clitool.tx_queue, net_queue, config))
+
+    return tasks
+
+
+# {'AltitudeBaro': nan,
+#  'AltitudeGeo': 212.0,
+#  'AreaCeiling': nan,
+#  'AreaCount': 1,
+#  'AreaFloor': nan,
+#  'AreaRadius': 500,
+#  'BaroAccuracy': 4,
+#  'CategoryEU': 1,
+#  'ClassEU': 5,
+#  'ClassificationType': 1,
+#  'Desc': 'Recreational',
+#  'DescType': 0,
+#  'Direction': 126.0,
+#  'Height': 115.5,
+#  'HeightType': 0,
+#  'HorizAccuracy': 10,
+#  'Latitude': 37.7599566,
+#  'Longitude': -122.4983164,
+#  'OperatorAltitudeGeo': 96.0,
+#  'OperatorID': 'WCzFzGDgIzxEnUcT',
+#  'OperatorIdType': 0,
+#  'OperatorLatitude': 37.7599983,
+#  'OperatorLocationType': 0,
+#  'OperatorLongitude': -122.4973975,
+#  'SpeedAccuracy': 1,
+#  'SpeedHorizontal': 12.75,
+#  'SpeedVertical': nan,
+#  'Status': 0,
+#  'TSAccuracy': 15,
+#  'Timestamp': ('2041-06-11 01:04 UTC',),
+#  'TimestampRaw': 708224640,
+#  'VertAccuracy': 4}
+
+
+def rid_op_to_cot_xml(  # NOQA pylint: disable=too-many-locals,too-many-branches,too-many-statements
+    data: dict,
+    config: Union[SectionProxy, dict, None] = None,
+) -> Optional[ET.Element]:
+    """
+    Serialize Open Drone ID data as Cursor on Target.
+
+    Parameters
+    ----------
+    craft : `dict`
+        Key/Value data struct of decoded ADS-B aircraft data.
+    config : `configparser.SectionProxy`
+        Configuration options and values.
+        Uses config options: UID_KEY, COT_STALE, COT_HOST_ID
+    kown_craft : `dict`
+        Optional list of know craft to transform CoT data.
+
+    Returns
+    -------
+    `xml.etree.ElementTree.Element`
+        Cursor-On-Target XML ElementTree object.
+    """
+    lat = data.get("OperatorLatitude")
+    lon = data.get("OperatorLongitude")
+
+    if lat is None or lon is None:
+        return None
+
+    config = config or {}
+    remarks_fields: list = []
+
+    op_id = data.get("OperatorID", "Unknown-OperatorID")
+    uasid = data.get("BasicID_0", "Unknown-BasicID_0")
+
+    cot_uid: str = f"RID.{op_id}"
+    cot_type: str = "a-n-G"
+
+    cot_stale: int = int(config.get("COT_STALE", pytak.DEFAULT_COT_STALE))
+    cot_host_id: str = config.get("COT_HOST_ID", pytak.DEFAULT_HOST_ID)
+
+    cotx = ET.Element("_dronecot_")
+    cotx.set("cot_host_id", cot_host_id)
+
+    remarks_fields.append(f"UAS ID={uasid} OperatorID={op_id}")
+    cotx.set("OperatorID", op_id)
+    cotx.set("UASID", op_id)
+    callsign = op_id
+
+    contact: ET.Element = ET.Element("contact")
+    contact.set("callsign", callsign)
+
+    detail = ET.Element("detail")
+    detail.append(contact)
+    detail.append(cotx)
+
+    remarks = ET.Element("remarks")
+    remarks_fields.append(f"{cot_host_id}")
+    _remarks = " ".join(list(filter(None, remarks_fields)))
+    remarks.text = _remarks
+    detail.append(remarks)
+
+    cot_d = {
+        "lat": str(lat),
+        "lon": str(lon),
+        "ce": str(data.get("HorizAccuracy", "9999999.0")),
+        "le": str(data.get("VertAccuracy", "9999999.0")),
+        "hae": str(data.get("OperatorAltitudeGeo", "9999999.0")),
+        "uid": cot_uid,
+        "cot_type": cot_type,
+        "stale": cot_stale,
+    }
+    cot = pytak.gen_cot_xml(**cot_d)
+    cot.set("access", config.get("COT_ACCESS", pytak.DEFAULT_COT_ACCESS))
+
+    _detail = cot.findall("detail")[0]
+    flowtags = _detail.findall("_flow-tags_")
+    detail.extend(flowtags)
+    cot.remove(_detail)
+    cot.append(detail)
+
+    return cot
+
+
+def rid_uas_to_cot_xml(  # NOQA pylint: disable=too-many-locals,too-many-branches,too-many-statements
+    data: dict,
+    config: Union[SectionProxy, dict, None] = None,
+) -> Optional[ET.Element]:
+    """
+    Serialize Open Drone ID data as Cursor on Target.
+
+    Parameters
+    ----------
+    craft : `dict`
+        Key/Value data struct of decoded ADS-B aircraft data.
+    config : `configparser.SectionProxy`
+        Configuration options and values.
+        Uses config options: UID_KEY, COT_STALE, COT_HOST_ID
+    kown_craft : `dict`
+        Optional list of know craft to transform CoT data.
+
+    Returns
+    -------
+    `xml.etree.ElementTree.Element`
+        Cursor-On-Target XML ElementTree object.
+    """
+    lat = data.get("Latitude")
+    lon = data.get("Longitude")
+
+    if lat is None or lon is None:
+        return None
+
+    config = config or {}
+    remarks_fields: list = []
+
+    op_id = data.get("OperatorID", "Unknown-OperatorID")
+    uasid = data.get("BasicID_0", "Unknown-BasicID_0")
+
+    cot_uid: str = f"RID.{uasid}"
+    cot_type: str = "a-n-A-M-F-Q"
+
+    cot_stale: int = int(config.get("COT_STALE", pytak.DEFAULT_COT_STALE))
+    cot_host_id: str = config.get("COT_HOST_ID", pytak.DEFAULT_HOST_ID)
+
+    cotx = ET.Element("_dronecot_")
+    cotx.set("cot_host_id", cot_host_id)
+
+    remarks_fields.append(f"OperatorID={op_id}")
+    cotx.set("OperatorID", op_id)
+    callsign = uasid
+
+    contact: ET.Element = ET.Element("contact")
+    contact.set("callsign", callsign)
+
+    track: ET.Element = ET.Element("track")
+    track.set("speed", str(data.get("SpeedHorizontal", 0)))
+
+    link: ET.Element = ET.Element("link")
+    link.set("uid", op_id)
+    link.set("production_time", pytak.cot_time())
+    link.set("type", "a-n-G")
+    link.set("parent_callsign", op_id)
+    link.set("relation", "p-p")
+
+    detail = ET.Element("detail")
+    detail.append(contact)
+    detail.append(track)
+    detail.append(cotx)
+    detail.append(link)
+
+    remarks = ET.Element("remarks")
+    remarks_fields.append(f"{cot_host_id}")
+    _remarks = " ".join(list(filter(None, remarks_fields)))
+    remarks.text = _remarks
+    detail.append(remarks)
+
+    cot_d = {
+        "lat": str(lat),
+        "lon": str(lon),
+        "ce": str(data.get("HorizAccuracy", "9999999.0")),
+        "le": str(data.get("VertAccuracy", "9999999.0")),
+        "hae": str(data.get("AltitudeGeo", "9999999.0")),
+        "uid": cot_uid,
+        "cot_type": cot_type,
+        "stale": cot_stale,
+    }
+    cot = pytak.gen_cot_xml(**cot_d)
+    cot.set("access", config.get("COT_ACCESS", pytak.DEFAULT_COT_ACCESS))
+
+    _detail = cot.findall("detail")[0]
+    flowtags = _detail.findall("_flow-tags_")
+    detail.extend(flowtags)
+    cot.remove(_detail)
+    cot.append(detail)
+
+    return cot
+
+
+def sensor_status_to_cot(  # NOQA pylint: disable=too-many-locals,too-many-branches,too-many-statements
+    data: dict,
+    config: Union[SectionProxy, dict, None] = None,
+) -> Optional[ET.Element]:
+    """Serialize sensor status data s Cursor on Target."""
+    config = config or {}
+    lat = config.get("SENSOR_LAT")
+    lon = config.get("SENSOR_LON")
+    alt = config.get("SENSOR_ALT", "9999999.0")
+
+    if lat is None or lon is None:
+        gps_info = get_gps_info(config)
+        if gps_info:
+            print(gps_info)
+        else:
+            return None
+
+    if lat is None or lon is None:
+        return None
+
+    config = config or {}
+    remarks_fields: list = []
+
+    sensor_id = config.get("SENSOR_ID", "Unknown-SENSOR_ID")
+
+    cot_uid: str = f"CUAS.{sensor_id}"
+    cot_type: str = "a-f-G-E-S"
+
+    cot_stale: int = int(config.get("COT_STALE", pytak.DEFAULT_COT_STALE))
+    cot_host_id: str = config.get("COT_HOST_ID", pytak.DEFAULT_HOST_ID)
+
+    cotx = ET.Element("_dronecot_")
+    cotx.set("cot_host_id", cot_host_id)
+
+    remarks_fields.append(f"C-UAS Sensor {sensor_id}")
+    cotx.set("sensor_id", sensor_id)
+    callsign = sensor_id
+
+    contact: ET.Element = ET.Element("contact")
+    contact.set("callsign", callsign)
+
+    track: ET.Element = ET.Element("track")
+    track.set("speed", str(data.get("SpeedHorizontal", 0)))
+
+    detail = ET.Element("detail")
+    detail.append(contact)
+    detail.append(track)
+    detail.append(cotx)
+
+    remarks = ET.Element("remarks")
+    remarks_fields.append(f"{cot_host_id}")
+    _remarks = " ".join(list(filter(None, remarks_fields)))
+    remarks.text = _remarks
+    detail.append(remarks)
+
+    cot_d = {
+        "lat": str(lat),
+        "lon": str(lon),
+        "ce": str(data.get("HorizAccuracy", "9999999.0")),
+        "le": str(data.get("VertAccuracy", "9999999.0")),
+        "hae": str(data.get("AltitudeGeo", "9999999.0")),
+        "uid": cot_uid,
+        "cot_type": cot_type,
+        "stale": cot_stale,
+    }
+    cot = pytak.gen_cot_xml(**cot_d)
+    cot.set("access", config.get("COT_ACCESS", pytak.DEFAULT_COT_ACCESS))
+
+    _detail = cot.findall("detail")[0]
+    flowtags = _detail.findall("_flow-tags_")
+    detail.extend(flowtags)
+    cot.remove(_detail)
+    cot.append(detail)
+
+    return cot
+
+
+def xml_to_cot(
+    data: dict, config: Union[SectionProxy, dict, None] = None, func=None
+) -> Optional[bytes]:
+    """Return CoT XML object as an XML string."""
+    cot: Optional[ET.Element] = getattr(dronecot.functions, func)(data, config)
+    return (
+        b"\n".join([pytak.DEFAULT_XML_DECLARATION, ET.tostring(cot)]) if cot else None
+    )
+
+
+def get_gps_info(config) -> Optional[dict]:
+    """Get GPS Info data."""
+    gpspipe_data: Optional[str] = None
+    gps_data: Optional[str] = None
+    gps_info_cmd = config.get("GPS_INFO_CMD", dronecot.DEFAULT_GPS_INFO_CMD)
+
+    with os.popen(gps_info_cmd) as gps_info_cmd:
+        gpspipe_data = gps_info_cmd.read()
+
+    if not gpspipe_data:
+        return None
+
+    if "\n" in gpspipe_data:
+        for data in gpspipe_data.split("\n"):
+            if "TPV" in data:
+                gps_data = data
+                continue
+
+    if not gps_data:
+        return None
+
+    gps_info = json.loads(gps_data)
+    return gps_info