fprime-gds 4.0.0a2__tar.gz → 4.0.0a3__tar.gz

{fprime_gds-4.0.0a2 → fprime_gds-4.0.0a3}/.github/actions/spelling/expect.txt

@@ -39,6 +39,7 @@ callgraph
 cata
 CCB
 CCFF
+ccsds
 Cdioux
 cdn
 cdxoefg
@@ -303,6 +304,7 @@ rollup
 rpaetz
 rst
 saba
+scid
 sdd
 searchdata
 Segoe
@@ -318,6 +320,7 @@ SMAP
 Smath
 SNDHWM
 sorttable
+spacepacket
 squashify
 sss
 Ssymbols
@@ -376,6 +379,8 @@ usec
 useconds
 usepackage
 usr
+vcid
+VCP
 vh
 vhd
 vhdl

{fprime_gds-4.0.0a2 → fprime_gds-4.0.0a3}/.github/actions/spelling/patterns.txt

@@ -44,3 +44,6 @@ value="(?:[0-9a-f]{1,2} )*"
 
 # Ignore any text between inline back-ticks
 `(.*?)`
+
+# Python struct packing patterns
+["\']([<>])[xcbB?hHiIlLqQnNefdspP]+["\']

{fprime_gds-4.0.0a2 → fprime_gds-4.0.0a3}/.github/workflows/fprime-gds-tests.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
 
     steps:
       - uses: actions/checkout@v4

{fprime_gds-4.0.0a2 → fprime_gds-4.0.0a3}/.github/workflows/gds-cli-tests.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
 
     steps:
 

{fprime_gds-4.0.0a2 → fprime_gds-4.0.0a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fprime-gds
-Version: 4.0.0a2
+Version: 4.0.0a3
 Summary: F Prime Flight Software Ground Data System layer
 Author-email: Michael Starch <Michael.D.Starch@jpl.nasa.gov>, Thomas Boyer-Chammard <Thomas.Boyer.Chammard@jpl.nasa.gov>
 License: 
@@ -216,15 +216,15 @@ Classifier: Operating System :: Unix
 Classifier: Operating System :: POSIX
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: License :: OSI Approved :: Apache Software License
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 License-File: NOTICE.txt
@@ -241,6 +241,8 @@ Requires-Dist: openpyxl>=3.0.10
 Requires-Dist: pyserial>=3.5
 Requires-Dist: pydantic>=2.6
 Requires-Dist: PyYAML>=6.0.2
+Requires-Dist: spacepackets>=0.28.0
+Requires-Dist: crc>=7.0.0
 Dynamic: license-file
 
 # F´ GDS

{fprime_gds-4.0.0a2 → fprime_gds-4.0.0a3}/pyproject.toml

@@ -7,7 +7,7 @@ name = "fprime-gds"
 dynamic = ["version"]
 description = "F Prime Flight Software Ground Data System layer"
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 license = {file = "LICENSE.txt"}
 keywords = ["fprime", "embedded", "nasa", "flight", "software"]
 authors = [
@@ -21,11 +21,11 @@ classifiers = [
     "Operating System :: POSIX",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
     "License :: OSI Approved :: Apache Software License",
@@ -43,7 +43,9 @@ dependencies = [
     "openpyxl>=3.0.10",
     "pyserial>=3.5",
     "pydantic>=2.6",
-    "PyYAML>=6.0.2"
+    "PyYAML>=6.0.2",
+    "spacepackets>=0.28.0",
+    "crc>=7.0.0"
 ]
 
 [project.urls]

fprime_gds-4.0.0a3/src/fprime_gds/common/communication/ccsds/apid.py

@@ -0,0 +1,19 @@
+""" ccsds.apid: APID mapping functions for F´ data """
+from fprime_gds.common.utils.data_desc_type import DataDescType
+from fprime.common.models.serialize.numerical_types import U32Type
+
+class APID(object):
+    """ APID implementations """
+    #TODO: use the DataDescType configured by loading the dictionary
+
+    @classmethod
+    def from_type(cls, data_type: DataDescType):
+        """ Map from data description type to APID """
+        return data_type.value
+
+    @classmethod
+    def from_data(cls, data):
+        """ Map from data bytes to APID """
+        u32_type = U32Type()
+        u32_type.deserialize(data, offset=0)
+        return cls.from_type(DataDescType(u32_type.val))

fprime_gds-4.0.0a3/src/fprime_gds/common/communication/ccsds/chain.py

@@ -0,0 +1,106 @@
+""" fprime_encryption.framing.chain: implementation of a chained framer/deframer """
+from abc import ABC, abstractmethod
+from functools import reduce
+from typing import Any, Dict, List, Type
+from fprime_gds.common.communication.framing import FramerDeframer
+from fprime_gds.common.communication.ccsds.space_data_link import SpaceDataLinkFramerDeframer
+from fprime_gds.common.communication.ccsds.space_packet import SpacePacketFramerDeframer
+from fprime_gds.plugin.definitions import gds_plugin
+
+
+
+class ChainedFramerDeframer(FramerDeframer, ABC):
+    """ Framer/deframer that is a composite of chained framer/deframers
+
+    This Framer/Deframer will wrap a set of framer/deframers where the result of the frame and deframe options will pass
+    from one to the other subsequently. The order is specified via the framing path and deframing will use the reverse
+    order from specified.
+    """
+    def __init__(self, **kwargs):
+        """ Initialize the chained framer/deframer from a framing-ordered set of children """
+        frame_order_framer_deframers = [
+            composite(**self.get_argument_subset(composite, kwargs))
+            for composite in self.get_composites()
+        ]
+        self.framers = frame_order_framer_deframers[::1]
+        self.deframers = frame_order_framer_deframers[::-1]
+
+    @classmethod
+    @abstractmethod
+    def get_composites(cls) -> List[Type[FramerDeframer]]:
+        """ Return a list of composites 
+        Innermost FramerDeframer should be first in the list. """
+        raise NotImplementedError(f"Subclasses of {cls.__name__} must implement get_composites")
+
+    @staticmethod
+    def get_argument_subset(composite: Type[FramerDeframer], argument_dictionary: Dict[str, Any]) -> Dict[str, Any]:
+        """ Get an argument subset that is needed by composite
+
+        For the composite, find the set of arguments that is needed by this composite and pull those out of the complete
+        argument dictionary.
+
+        Args:
+            composite: class of a subtype of FramerDeframer
+            argument_dictionary: dictionary of all input arguments
+        """
+        if not hasattr(composite, "get_arguments"):
+            return {}
+        needed_arguments = composite.get_arguments()
+        needed_argument_destinations = [
+            description["destination"] if "destination" in description else
+                [dash_dash for dash_dash in flag if dash_dash.startswith("--")][0].lstrip("-").replace("-", "_")
+            for flag, description in needed_arguments.items()
+        ]
+        return {name: argument_dictionary[name] for name in needed_argument_destinations}
+
+    @classmethod
+    def get_arguments(cls):
+        """ Arguments to request from the CLI """
+        all_arguments = {}
+        for composite in cls.get_composites():
+            all_arguments.update(composite.get_arguments() if hasattr(composite, "get_arguments") else {})
+        return all_arguments
+
+    @classmethod
+    def check_arguments(cls, **kwargs):
+        """ Check arguments from the CLI """
+        for composite in cls.get_composites():
+            subset_arguments = cls.get_argument_subset(composite, kwargs)
+            if hasattr(composite, "check_arguments"):
+                composite.check_arguments(**subset_arguments)
+
+    def deframe(self, data, no_copy=False):
+        """ Deframe via a chain of children deframers """
+        packet = data[:] if not no_copy else data
+        remaining = None
+        discarded = b""
+
+        for deframer in self.deframers:
+            new_packet, new_remaining, new_discarded = deframer.deframe(packet, True)
+            discarded += new_discarded
+            remaining = new_remaining if remaining is None else remaining
+            packet = new_packet
+        return packet, remaining, discarded
+
+    def frame(self, data):
+        """ Frame via a chain of children framers """
+        return reduce(lambda framed_data, framer: framer.frame(framed_data), self.framers, data)
+
+
+@gds_plugin(FramerDeframer)
+class SpacePacketSpaceDataLinkFramerDeframer(ChainedFramerDeframer):
+    """ Space Data Link Protocol framing and deframing that has a data unit of Space Packets as the central """
+
+    @classmethod
+    def get_composites(cls) -> List[Type[FramerDeframer]]:
+        """ Return the composite list of this chain 
+        Innermost FramerDeframer should be first in the list. """
+        return [
+            SpacePacketFramerDeframer,
+            SpaceDataLinkFramerDeframer
+        ]
+
+    @classmethod
+    def get_name(cls):
+        """ Name of this implementation provided to CLI """
+        return "space-packet-space-data-link"

fprime_gds-4.0.0a3/src/fprime_gds/common/communication/ccsds/space_data_link.py

@@ -0,0 +1,196 @@
+"""F Prime Framer/Deframer Implementation of the CCSDS Space Data Link (TC/TM) Protocols"""
+import sys
+import struct
+import copy
+
+from fprime_gds.common.communication.framing import FramerDeframer
+from fprime_gds.plugin.definitions import gds_plugin_implementation
+
+import crc
+
+
+class SpaceDataLinkFramerDeframer(FramerDeframer):
+    """CCSDS Framer/Deframer Implementation for the TC (uplink / framing) and TM (downlink / deframing)
+    protocols. This FramerDeframer is used for framing TC data for uplink and deframing TM data for downlink.
+    """
+
+    SEQUENCE_NUMBER_MAXIMUM = 256
+    TC_HEADER_SIZE = 5
+    TM_HEADER_SIZE = 6
+    TM_FIXED_FRAME_SIZE = 1024
+    TM_TRAILER_SIZE = 2
+    TC_TRAILER_SIZE = 2
+
+    # As per CCSDS standard, use CRC-16 CCITT config with init value
+    # all 1s and final XOR value of 0x0000
+    CRC_CCITT_CONFIG = crc.Configuration(
+        width=16,
+        polynomial=0x1021,
+        init_value=0xFFFF,
+        final_xor_value=0x0000,
+    )
+    CRC_CALCULATOR = crc.Calculator(CRC_CCITT_CONFIG)
+
+    def __init__(self, scid, vcid):
+        """ """
+        self.scid = scid
+        self.vcid = vcid
+        self.sequence_number = 0
+
+    def frame(self, data):
+        """Frame the supplied data in a TC frame"""
+        space_packet_bytes = data
+        # CCSDS TC protocol defines the length token as number of bytes in full frame, minus 1
+        # so we add to packet size the size of the header and trailer and subtract 1
+        length = (
+            len(space_packet_bytes) + self.TC_HEADER_SIZE + self.TC_TRAILER_SIZE - 1
+        )
+        assert length < (pow(2, 10) - 1), "Length too-large for CCSDS format"
+
+        # CCSDS TC Header:
+        #  2b -  00 - TF version number
+        #  1b - 0/1 - 0 enable FARM checks, 1 bypass FARM
+        #  1b - 0/1 - 0 = data (Type-D), 1 = control information (Type-C)
+        #  2b -  00 - Reserved
+        # 10b -  XX - Spacecraft id
+        #  6b -  XX - Virtual Channel ID
+        # 10b -  XX - Frame length
+        #  8b -  XX - Frame sequence number
+
+        # First 16 bits:
+        header_val1_u16 = (
+            (0 << 14) |  # TF version number (2 bits)
+            (1 << 13) |  # Bypass FARM (1 bit)
+            (0 << 12) |  # Type-D (1 bit)
+            (0 << 10) |  # Reserved (2 bits)
+            ((self.scid & 0x3FF))  # SCID (10 bits)
+        )
+        # Second 16 bits:
+        header_val2_u16 = (
+            ((self.vcid & 0x3F) << 10) |  # VCID (6 bits)
+            (length & 0x3FF)              # Frame length (10 bits)
+        )
+        # 8 bit sequence number - always 0 in bypass FARM mode
+        header_val3_u8 = 0
+        header_bytes = struct.pack(">HHB", header_val1_u16, header_val2_u16, header_val3_u8)
+        full_bytes_no_crc = header_bytes + space_packet_bytes
+        assert (
+            len(header_bytes) == self.TC_HEADER_SIZE
+        ), "CCSDS primary header must be 5 octets long"
+        assert len(full_bytes_no_crc) == self.TC_HEADER_SIZE + len(
+            data
+        ), "Malformed packet generated"
+
+        full_bytes = full_bytes_no_crc + struct.pack(
+            ">H", self.CRC_CALCULATOR.checksum(full_bytes_no_crc)
+        )
+        return full_bytes
+
+    def get_sequence_number(self):
+        """Get the sequence number and increment - used for TM deframing
+
+        This function will return the current sequence number and then increment the sequence number for the next round.
+
+        Return:
+            current sequence number
+        """
+        sequence = self.sequence_number
+        self.sequence_number = (self.sequence_number + 1) % self.SEQUENCE_NUMBER_MAXIMUM
+        return sequence
+
+    def deframe(self, data, no_copy=False):
+        """Deframe TM frames"""
+        discarded = b""
+        if not no_copy:
+            data = copy.copy(data)
+        # Continue until there is not enough data for the header, or until a packet is found (return)
+        while len(data) >= self.TM_FIXED_FRAME_SIZE:
+            # Read header information
+            sc_and_channel_ids = struct.unpack_from(">H", data)
+            spacecraft_id = (sc_and_channel_ids[0] & 0x3FF0) >> 4
+            virtual_channel_id = (sc_and_channel_ids[0] & 0x000E) >> 1
+            # Check if the header is correct with regards to expected spacecraft and VC IDs
+            if spacecraft_id != self.scid or virtual_channel_id != self.vcid:
+                # If the header is invalid, rotate away a Byte and keep processing
+                discarded += data[0:1]
+                data = data[1:]
+                continue
+            # Spacecraft ID and Virtual Channel ID match, so we look at end of frame for CRC
+            crc_offset = self.TM_FIXED_FRAME_SIZE - self.TM_TRAILER_SIZE
+            transmitted_crc = struct.unpack_from(">H", data, crc_offset)[0]
+            if transmitted_crc == self.CRC_CALCULATOR.checksum(data[:crc_offset]):
+                # CRC is valid, so we return the deframed data
+                deframed_data_len = (
+                    self.TM_FIXED_FRAME_SIZE
+                    - self.TM_TRAILER_SIZE
+                    - self.TM_HEADER_SIZE
+                )
+                deframed = struct.unpack_from(
+                    f">{deframed_data_len}s", data, self.TM_HEADER_SIZE
+                )[0]
+                # Consume the fixed size frame
+                data = data[self.TM_FIXED_FRAME_SIZE :]
+                return deframed, data, discarded
+
+            print(
+                "[WARNING] Checksum validation failed.",
+                file=sys.stderr,
+            )
+            # Bad checksum, rotate 1 and keep looking for non-garbage
+            discarded += data[0:1]
+            data = data[1:]
+            continue
+        return None, data, discarded
+
+    @classmethod
+    def get_arguments(cls):
+        """Arguments to request from the CLI"""
+        return {
+            ("--scid",): {
+                "type": lambda input_arg: int(input_arg, 0),
+                "help": "Spacecraft ID",
+                "default": 0x44,
+                "required": False,
+            },
+            ("--vcid",): {
+                "type": lambda input_arg: int(input_arg, 0),
+                "help": "Virtual channel ID",
+                "default": 1,
+                "required": False,
+            },
+        }
+
+    @classmethod
+    def check_arguments(cls, scid, vcid):
+        """Check arguments from the CLI
+
+        Confirms that the input arguments are valid for this framer/deframer.
+
+        Args:
+            scid: spacecraft id
+            vcid: virtual channel id
+        """
+        if scid is None:
+            raise TypeError(f"Spacecraft ID not specified")
+        if scid < 0:
+            raise TypeError(f"Spacecraft ID {scid} is negative")
+        if scid > 0x3FF:
+            raise TypeError(f"Spacecraft ID {scid} is larger than {0x3FF}")
+
+        if vcid is None:
+            raise TypeError(f"Virtual Channel ID not specified")
+        if vcid < 0:
+            raise TypeError(f"Virtual Channel ID {vcid} is negative")
+        if vcid > 0x3F:
+            raise TypeError(f"Virtual Channel ID {vcid} is larger than {0x3FF}")
+
+    @classmethod
+    def get_name(cls):
+        """Name of this implementation provided to CLI"""
+        return "raw-space-data-link"
+
+    @classmethod
+    @gds_plugin_implementation
+    def register_framing_plugin(cls):
+        """Register the MyPlugin plugin"""
+        return cls

fprime_gds-4.0.0a3/src/fprime_gds/common/communication/ccsds/space_packet.py

@@ -0,0 +1,130 @@
+"""F Prime Framer/Deframer Implementation of the CCSDS Space Packet Protocol"""
+
+from __future__ import annotations
+
+import struct
+import copy
+
+from spacepackets.ccsds.spacepacket import SpacePacketHeader, PacketType, SpacePacket
+
+from fprime_gds.common.communication.framing import FramerDeframer
+from fprime_gds.plugin.definitions import gds_plugin_implementation, gds_plugin
+from fprime_gds.common.utils.data_desc_type import DataDescType
+
+from .apid import APID
+import logging
+
+LOGGER = logging.getLogger("framing")
+LOGGER.setLevel(logging.DEBUG)
+
+
+@gds_plugin(FramerDeframer)
+class SpacePacketFramerDeframer(FramerDeframer):
+    """Concrete implementation of FramerDeframer supporting SpacePacket protocol
+
+    This implementation is registered as a "framing" plugin to support encryption within the GDS layer.
+    """
+
+    SEQUENCE_COUNT_MAXIMUM = 16384  # 2^14
+    HEADER_SIZE = 6
+    IDLE_APID = 0x7FF  # max 11 bit value per protocol specification
+
+    def __init__(self):
+        # self.sequence_number = 0
+        # Map APID to sequence counts
+        self.apid_to_sequence_count_map = dict()
+        for key in DataDescType:
+            self.apid_to_sequence_count_map[key.value] = 0
+
+    def frame(self, data):
+        """Frame the supplied data in Space Packet"""
+        # The protocol defines length token to be number of bytes minus 1
+        data_length_token = len(data) - 1
+        apid = APID.from_data(data)
+        space_header = SpacePacketHeader(
+            packet_type=PacketType.TC,
+            apid=apid,
+            seq_count=self.get_sequence_count(apid),
+            data_len=data_length_token,
+        )
+        space_packet = SpacePacket(space_header, sec_header=None, user_data=data)
+        return space_packet.pack()
+
+    def deframe(self, data, no_copy=False):
+        """Deframe the supplied data according to Space Packet protocol"""
+        discarded = b""
+        if data is None:
+            return None, None, discarded
+        if not no_copy:
+            data = copy.copy(data)
+        # Deframe all packets until there is not enough data for a header
+        while len(data) >= self.HEADER_SIZE:
+            # Read header information including start token and size and check if we have enough for the total size
+            try:
+                sp_header = SpacePacketHeader.unpack(data)
+            except ValueError:
+                # If the header is invalid, rotate away a byte and keep processing
+                discarded += data[0:1]
+                data = data[1:]
+                continue
+            if sp_header.ccsds_version != 0 or sp_header.packet_type != PacketType.TM:
+                # Space Packet version is specified as 0 per protocol
+                discarded += data[0:1]
+                data = data[1:]
+                continue
+            # Skip Idle Packets as they are not meaningful
+            if sp_header.apid == self.IDLE_APID:
+                data = data[sp_header.packet_len :]
+                continue
+            # Check sequence count and warn if not expected value (don't drop the packet)
+            if sp_header.seq_count != self.get_sequence_count(sp_header.apid):
+                LOGGER.warning(
+                    f"APID {sp_header.apid} received sequence count: {sp_header.seq_count}"
+                    f" (expected: {self.get_sequence_count(sp_header.apid)})"
+                )
+                # Set the sequence count to the next expected value (consider missing packets have been lost)
+                self.apid_to_sequence_count_map[sp_header.apid] = (
+                    sp_header.seq_count + 1
+                )
+            # If the pool is large enough to read the whole packet, then read it
+            if len(data) >= sp_header.packet_len:
+                deframed = struct.unpack_from(
+                    # data_len is number of bytes minus 1 per SpacePacket spec
+                    f">{sp_header.data_len + 1}s",
+                    data,
+                    self.HEADER_SIZE,
+                )[0]
+                data = data[sp_header.packet_len :]
+                LOGGER.debug(f"Deframed packet: {sp_header}")
+                return deframed, data, discarded
+            else:
+                # If we don't have enough data, then break out of the loop
+                break
+        return None, data, discarded
+
+    def get_sequence_count(self, apid: int):
+        """Get the sequence number and increment
+
+        This function will return the current sequence number and then increment the sequence number for the next round.
+        Should an APID not be registered already, it will be initialized to 0.
+
+        Return:
+            current sequence number
+        """
+        # If APID is not registered, initialize it to 0
+        sequence = self.apid_to_sequence_count_map.get(apid, 0)
+        self.apid_to_sequence_count_map[apid] = (
+            sequence + 1
+        ) % self.SEQUENCE_COUNT_MAXIMUM
+        return sequence
+
+    @classmethod
+    def get_name(cls):
+        """Name of this implementation provided to CLI"""
+        return "raw-space-packet"
+
+    @classmethod
+    @gds_plugin_implementation
+    def register_framing_plugin(cls):
+        """Register the MyPlugin plugin"""
+        return cls