fprime-gds 3.6.2a1__py3-none-any.whl → 4.0.0__py3-none-any.whl

fprime_gds/common/communication/framing.py

@@ -11,6 +11,8 @@ that implement this pattern. The current list of implementation classes are:
 
 @author lestarch
 """
+
+from __future__ import annotations
 import abc
 import copy
 import struct
@@ -18,7 +20,10 @@ import sys
 from typing import Type
 
 from .checksum import calculate_checksum, CHECKSUM_MAPPING
-from fprime_gds.plugin.definitions import gds_plugin_implementation, gds_plugin_specification
+from fprime_gds.plugin.definitions import (
+    gds_plugin_implementation,
+    gds_plugin_specification,
+)
 
 
 class FramerDeframer(abc.ABC):
@@ -28,7 +33,7 @@ class FramerDeframer(abc.ABC):
     """
 
     @abc.abstractmethod
-    def frame(self, data):
+    def frame(self, data: bytes) -> bytes:
         """
         Frames outgoing data in the specified format. Expects incoming raw bytes to frame, and adds on the needed header
         and footer bytes. This new array of bytes is returned from the method.
@@ -38,20 +43,27 @@ class FramerDeframer(abc.ABC):
         """
 
     @abc.abstractmethod
-    def deframe(self, data, no_copy=False):
+    def deframe(
+        self, data: bytes, no_copy=False
+    ) -> tuple[(bytes | None), bytes, bytes]:
         """
-        Deframes the incoming data from the specified format. Produces exactly one packet, and leftover bytes. Users
-        wanting all packets to be deframed should call "deframe_all". If no full packet is available, this method
+        Deframes the incoming data from the specified format. 
+        Produces:
+        - One packet, or None if no packet found
+        - leftover bytes (not consumed yet)
+        - Discarded data (consumed and determined not to be valid)
+
+        Users wanting all packets to be deframed should call "deframe_all". If no full packet is available, this method
         returns None. Expects incoming raw bytes to deframe, and returns a deframed packet or None, the leftover
         bytes that were unused, and any bytes discarded from the existing data stream. Will search and discard data up
         until a start token is found. Note: data will be consumed up to the first start token found.
 
         :param data: framed data bytes
         :param no_copy: (optional) will prevent extra copy if True, but "data" input will be destroyed.
-        :return: (packet as array of bytes or None, leftover bytes, any discarded data)
+        :return: (packet as bytes or None, leftover bytes, any discarded data)
         """
 
-    def deframe_all(self, data, no_copy):
+    def deframe_all(self, data: bytes, no_copy: bool):
         """
         Deframes all available packets found in a single set of bytes by calling deframe until a None packet is
         retrieved. This list of packets, and the remaining bytes are returned
@@ -66,11 +78,11 @@ class FramerDeframer(abc.ABC):
         discarded_aggregate = b""
         while True:
             # Deframe and return only on None
-            (packet, data, discarded) = self.deframe(data, no_copy=True)
+            (deframed, data, discarded) = self.deframe(data, no_copy=True)
             discarded_aggregate += discarded
-            if packet is None:
+            if deframed is None: # No more packets available, return aggregate
                 return packets, data, discarded_aggregate
-            packets.append(packet)
+            packets.append(deframed)
 
     @classmethod
     @gds_plugin_specification
@@ -117,7 +129,7 @@ class FpFramerDeframer(FramerDeframer):
     HEADER_FORMAT = None
     START_TOKEN = None
 
-    def __init__(self, checksum_type):
+    def __init__(self, checksum_type="crc32"):
         """Sets constants on construction."""
         # Setup the constants as soon as possible.
         FpFramerDeframer.set_constants()
@@ -197,13 +209,12 @@ class FpFramerDeframer(FramerDeframer):
                 )
                 # If the checksum is valid, return the packet. Otherwise continue to rotate
                 if check == calculate_checksum(
-                    data[: data_size + FpFramerDeframer.HEADER_SIZE],
-                    self.checksum
+                    data[: data_size + FpFramerDeframer.HEADER_SIZE], self.checksum
                 ):
                     data = data[total_size:]
                     return deframed, data, discarded
                 print(
-                    "[WARNING] Checksum validation failed. Have you correctly set '--comm-checksum-type'",
+                    "[WARNING] Checksum validation failed.",
                     file=sys.stderr,
                 )
                 # Bad checksum, rotate 1 and keep looking for non-garbage
@@ -216,29 +227,13 @@ class FpFramerDeframer(FramerDeframer):
 
     @classmethod
     def get_name(cls):
-        """ Get the name of this plugin """
+        """Get the name of this plugin"""
         return "fprime"
 
-    @classmethod
-    def get_arguments(cls):
-        """ Get arguments for the framer/deframer """
-        return {("--comm-checksum-type",): {
-            "dest": "checksum_type",
-            "action": "store",
-            "type": str,
-            "help": "Setup the checksum algorithm. [default: %(default)s]",
-            "choices": [
-                item
-                for item in CHECKSUM_MAPPING.keys()
-                if item != "default"
-            ],
-            "default": "crc32",
-        }}
-
     @classmethod
     @gds_plugin_implementation
     def register_framing_plugin(cls):
-        """ Register a bad plugin """
+        """Register a bad plugin"""
         return cls
 
 

fprime_gds/common/decoders/ch_decoder.py

@@ -44,7 +44,7 @@ class ChDecoder(Decoder):
             config = config_manager.ConfigManager().get_instance()
 
         self.__dict = ch_dict
-        self.id_obj = config.get_type("ch_id")
+        self.id_obj = config.get_type("FwChanIdType")
 
     def decode_api(self, data):
         """

fprime_gds/common/decoders/event_decoder.py

@@ -19,8 +19,11 @@ from fprime.common.models.serialize.type_exceptions import TypeException
 
 from fprime_gds.common.data_types import event_data
 from fprime_gds.common.decoders import decoder
+from fprime_gds.common.decoders.decoder import DecodingException
 from fprime_gds.common.utils import config_manager
 
+import logging
+LOGGER = logging.getLogger("event_decoder")
 
 class EventDecoder(decoder.Decoder):
     """Decoder class for event data"""
@@ -43,7 +46,7 @@ class EventDecoder(decoder.Decoder):
             config = config_manager.ConfigManager().get_instance()
 
         self.__dict = event_dict
-        self.id_obj = config.get_type("event_id")
+        self.id_obj = config.get_type("FwEventIdType")
 
     def decode_api(self, data):
         """
@@ -66,7 +69,11 @@ class EventDecoder(decoder.Decoder):
         while (ptr < len(data)):
 
             # Decode event ID here...
-            self.id_obj.deserialize(data, ptr)
+            if ptr + self.id_obj.getSize() <= len(data):
+                self.id_obj.deserialize(data, ptr)
+            else:
+                LOGGER.warning("Insufficient data for event ID")
+                break
             ptr += self.id_obj.getSize()
             event_id = self.id_obj.val
 

fprime_gds/common/decoders/pkt_decoder.py

@@ -45,7 +45,7 @@ class PktDecoder(ChDecoder):
         super().__init__(ch_dict, config)
 
         self.__dict = pkt_name_dict
-        self.id_obj = config.get_type("pkt_id")
+        self.id_obj = config.get_type("FwTlmPacketizeIdType")
 
     def decode_api(self, data):
         """

fprime_gds/common/distributor/distributor.py

@@ -57,7 +57,7 @@ class Distributor(DataHandler):
             self.key_frame = int(config.get("framing", "key_val"), 16)
         self.key_obj = config.get_type("key_val")
         self.len_obj = config.get_type("msg_len")
-        self.desc_obj = config.get_type("msg_desc")
+        self.desc_obj = config.get_type("FwPacketDescriptorType")
 
     # NOTE we could use either the type of the object or an enum as the type argument.
     # It should indicate what the decoder decodes.
@@ -199,9 +199,12 @@ class Distributor(DataHandler):
             (length, data_desc, msg) = self.parse_raw_msg_api(raw_msg)
 
             data_desc_key = data_desc_type.DataDescType(data_desc).name
-
             for d in self.__decoders[data_desc_key]:
                 try:
                     d.data_callback(msg)
                 except DecodingException as dexc:
-                    LOGGER.warning("Decoding error occurred: %s. Skipping.", dexc)
+                    LOGGER.warning("Decoding error: %s", dexc)
+                except Exception as exc:
+                    LOGGER.warning("Parsing error: %s", exc)
+            else:
+                LOGGER.warning("No decoder registered for: %s", data_desc_type.DataDescType(data_desc).name)

fprime_gds/common/encoders/ch_encoder.py

@@ -57,8 +57,8 @@ class ChEncoder(Encoder):
         super().__init__(config)
 
         self.len_obj = self.config.get_type("msg_len")
-        self.desc_obj = self.config.get_type("msg_desc")
-        self.id_obj = self.config.get_type("ch_id")
+        self.desc_obj = self.config.get_type("FwPacketDescriptorType")
+        self.id_obj = self.config.get_type("FwChanIdType")
 
     def encode_api(self, data):
         """

fprime_gds/common/encoders/cmd_encoder.py

@@ -72,8 +72,8 @@ class CmdEncoder(encoder.Encoder):
         super().__init__(config)
 
         self.len_obj = self.config.get_type("msg_len")
-        self.desc_obj = self.config.get_type("msg_desc")
-        self.opcode_obj = self.config.get_type("op_code")
+        self.desc_obj = self.config.get_type("FwPacketDescriptorType")
+        self.opcode_obj = self.config.get_type("FwOpcodeType")
 
     def encode_api(self, data):
         """

fprime_gds/common/encoders/event_encoder.py

@@ -61,8 +61,8 @@ class EventEncoder(Encoder):
         super().__init__(config)
 
         self.len_obj = self.config.get_type("msg_len")
-        self.desc_obj = self.config.get_type("msg_desc")
-        self.id_obj = self.config.get_type("event_id")
+        self.desc_obj = self.config.get_type("FwPacketDescriptorType")
+        self.id_obj = self.config.get_type("FwEventIdType")
 
     def encode_api(self, data):
         """

fprime_gds/common/encoders/pkt_encoder.py

@@ -61,8 +61,8 @@ class PktEncoder(Encoder):
         super().__init__(config)
 
         self.len_obj = self.config.get_type("msg_len")
-        self.desc_obj = self.config.get_type("msg_desc")
-        self.id_obj = self.config.get_type("pkt_id")
+        self.desc_obj = self.config.get_type("FwPacketDescriptorType")
+        self.id_obj = self.config.get_type("FwTlmPacketizeIdType")
 
     def encode_api(self, data):
         """

fprime_gds/common/encoders/seq_writer.py

@@ -28,8 +28,8 @@ class SeqBinaryWriter:
 
         self.__fd = None
         self.__timebase = timebase
-        self.desc_obj = config.get_type("msg_desc")
-        self.opcode_obj = config.get_type("op_code")
+        self.desc_obj = config.get_type("FwPacketDescriptorType")
+        self.opcode_obj = config.get_type("FwOpcodeType")
         self.len_obj = config.get_type("msg_len")
 
     def open(self, filename):

fprime_gds/common/fpy/README.md

@@ -0,0 +1,56 @@
+# Fpy Advanced Sequencing Language Version 0.1
+The Fpy advanced sequencing language is a combination of a high-level scripting language and a low-level bytecode language for running complex command sequences on spacecraft flight software.
+## Fpy Syntax
+### Modules, components, channels, commands and types
+You can imagine the Fpy syntax as Python with the following mappings:
+1. FPrime modules become Python namespaces
+2. FPrime components become Python classes
+3. FPrime types (structs, arrays and enums) become Python classes
+4. FPrime component instances become Python object instances
+5. FPrime commands become member functions of Python object instances
+6. FPrime telemetry channels become member properties of Python object instances
+
+FPrime declaration:
+```
+module Ref {
+    passive component ExampleComponent {
+        telemetry testChannel: U8
+        sync command TEST_COMMAND(arg: string size 40)
+    }
+
+    instance exampleInstance: ExampleComponent base id 0x01
+}
+```
+Fpy usage:
+```py
+# reference a telemetry channel
+Ref.exampleInstance.testChannel
+# call a command
+Ref.exampleInstance.TEST_COMMAND("arg value")
+```
+
+
+FPrime declaration:
+```
+struct ExampleStruct {
+    member: F32
+}
+
+enum TestEnum {
+    ONE
+    TWO
+    THREE
+}
+
+array TestArray = [3] U8
+```
+
+Fpy usage:
+```py
+# construct a struct
+ExampleStruct(0.0)
+# reference an enum const
+TestEnum.THREE
+# construct an array
+TestArray(1, 2, 3)
+```

fprime_gds/common/fpy/SPEC.md

@@ -0,0 +1,69 @@
+Nothing type is a type whose set of values is an empty set
+Unit type is a type whose set of values is a set with one element
+
+# `if` statement
+
+## Syntactical and semantic checks
+
+`"if" condition ":" INDENT stmt* DEDENT ("elif" condition ":" INDENT stmt* DEDENT)* ["else" ":" INDENT stmt* DEDENT]`
+
+1. where `condition` is an expression which evaluates to a boolean
+2. where `stmt` is a statement
+
+## Code generation
+
+1. `if` generates `IF`, followed by the generated code for the first body, followed by `GOTO` to the end of the if statement
+2. `elif` generates `IF`, followed by the generated code for its body, followed by `GOTO` to the end of the if statement
+3. `else` generates the code for its body
+
+# `not` boolean operator
+
+## Syntactical and semantic checks
+
+`"not" value` evaluates to a boolean at runtime
+
+1. where `value` is an expression which evaluates to a boolean
+
+## Code generation
+
+1. `not` generates `NOT`
+
+# `and` and `or` boolean operators
+
+## Syntactical and semantic checks
+
+`value (op value)+` evaluates to a boolean at runtime
+
+1. where `op: "and"|"or"`
+2. where `value` is an expression which evaluates to a boolean
+
+## Code generation
+
+1. Each `and` or `or` between two `value`s generates an `AND` or `OR`, respectively
+
+# Infix comparisons
+
+## Syntactical and semantic checks
+
+`lhs op rhs` evaluates to a boolean at runtime
+
+1. where `op: ">" | "<" | "<=" | ">=" | "==" | "!="`
+2. and `lhs`, `rhs` are expressions which evaluate to a number
+
+If either `lhs` or `rhs` evaluate to a float:
+3. both `lhs` and `rhs` must evaluate to floats of the same bit width
+
+Otherwise, `lhs` and `rhs` evaluate to integer values. All comparisons between integer values are valid.
+
+## Code generation
+
+### Equality comparisons
+
+1. `==` or `!=` between two floats generates `FEQ` or `FNE`, respectively
+2. `==` or `!=` between two ints generates `IEQ` or `INE`, respectively
+
+### Inequality comparisons
+
+1. `>`, `<`, `<=`, or `>=` between two floats generates `FGT`, `FLT`, `FLE` or `FGE`, respectively
+2. `>`, `<`, `<=`, or `>=` between two unsigned ints generates `UGT`, `ULT`, `ULE` or `UGE`, respectively
+2. `>`, `<`, `<=`, or `>=` between two ints, where at least one is signed, generates `SGT`, `SLT`, `SLE` or `SGE`, respectively