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

fprime_gds/common/communication/adapters/uart.py

@@ -59,7 +59,7 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         4000000,
     ]
 
-    def __init__(self, device, baud):
+    def __init__(self, device, baud, skip_check):
         """
         Initialize the serial adapter using the default settings. This does not open the serial port, but sets up all
         the internal variables used when opening the device.
@@ -77,9 +77,14 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         Opens the serial port based on previously supplied settings. If the port is already open, then close it first.
         Then open the port up again.
         """
-        self.close()
-        self.serial = serial.Serial(self.device, self.baud)
-        return self.serial is not None
+        try:
+            self.close()
+            self.serial = serial.Serial(self.device, self.baud)
+            return self.serial is not None
+        except serial.serialutil.SerialException as exc:
+            LOGGER.warning("Serial exception caught: %s. Reconnecting.", (str(exc)))
+            self.close()
+            return False
 
     def close(self):
         """
@@ -100,12 +105,11 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         :return: True, when data was sent through the UART. False otherwise.
         """
         try:
-            if self.serial is None:
-                self.open()
-            written = self.serial.write(frame)
-            # Not believed to be possible to not send everything without getting a timeout exception
-            assert written == len(frame)
-            return True
+            if self.serial is not None or self.open():
+                written = self.serial.write(frame)
+                # Not believed to be possible to not send everything without getting a timeout exception
+                assert written == len(frame)
+                return True
         except serial.serialutil.SerialException as exc:
             LOGGER.warning("Serial exception caught: %s. Reconnecting.", (str(exc)))
             self.close()
@@ -121,17 +125,16 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         """
         data = b""
         try:
-            if self.serial is None:
-                self.open()
-            # Read as much data as possible, while ensuring to block if no data is available at this time. Note: as much
-            # data is read as possible to avoid a long-return time to this call. Minimum data to read is one byte in
-            # order to block this function while data is incoming.
-            self.serial.timeout = timeout
-            data = self.serial.read(1)  # Force a block for at least 1 character
-            while self.serial.in_waiting:
-                data += self.serial.read(
-                    self.serial.in_waiting
-                )  # Drain the incoming data queue
+            if self.serial is not None or self.open():                
+                # Read as much data as possible, while ensuring to block if no data is available at this time. Note: as much
+                # data is read as possible to avoid a long-return time to this call. Minimum data to read is one byte in
+                # order to block this function while data is incoming.
+                self.serial.timeout = timeout
+                data = self.serial.read(1)  # Force a block for at least 1 character
+                while self.serial.in_waiting:
+                    data += self.serial.read(
+                        self.serial.in_waiting
+                    )  # Drain the incoming data queue
         except serial.serialutil.SerialException as exc:
             LOGGER.warning("Serial exception caught: %s. Reconnecting.", (str(exc)))
             self.close()
@@ -161,6 +164,12 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
                 "default": 9600,
                 "help": "Baud rate of the serial device.",
             },
+            ("--uart-skip-port-check",): {
+                "dest": "skip_check",
+                "default": False,
+                "action": "store_true",
+                "help": "Skip checking that the port exists"
+            }
         }
 
     @classmethod
@@ -175,20 +184,20 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         return cls
 
     @classmethod
-    def check_arguments(cls, device, baud):
+    def check_arguments(cls, device, baud, skip_check):
         """
         Code that should check arguments of this adapter. If there is a problem with this code, then a "ValueError"
         should be raised describing the problem with these arguments.
 
         :param args: arguments as dictionary
         """
-        ports = map(lambda info: info.device, list_ports.comports(include_links=True))
-        if device not in ports:
+        ports = list(map(lambda info: info.device, list_ports.comports(include_links=True)))
+        if not skip_check and device not in ports:
             msg = f"Serial port '{device}' not valid. Available ports: {ports}"
             raise ValueError(
                 msg
             )
-        # Note: baud rate may not *always* work. These are a superset
+        # Note: baud rate may not *always* work. These are a superset.
         try:
             baud = int(baud)
         except ValueError:

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,6 +19,7 @@ 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
 
 
@@ -43,7 +44,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):
         """

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.
@@ -204,4 +204,4 @@ class Distributor(DataHandler):
                 try:
                     d.data_callback(msg)
                 except DecodingException as dexc:
-                    LOGGER.warning("Decoding error occurred: %s. Skipping.", dexc)
+                    LOGGER.warning("Decoding error occurred: %s. Skipping.", dexc)

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/serialize_bytecode.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+from dataclasses import astuple
+import inspect
+import json
+from pathlib import Path
+from argparse import ArgumentParser
+import struct
+import zlib
+from fprime_gds.common.fpy.types import (
+    StatementTemplate,
+    StatementData,
+    Header,
+    Footer,
+    HEADER_FORMAT,
+    FOOTER_FORMAT,
+    StatementType,
+    FPY_DIRECTIVES,
+    BytecodeParseContext,
+    get_type_obj_for,
+)
+from fprime_gds.common.loaders.ch_json_loader import ChJsonLoader
+from fprime_gds.common.loaders.cmd_json_loader import CmdJsonLoader
+from fprime.common.models.serialize.numerical_types import (
+    U8Type,
+)
+
+from fprime_gds.common.loaders.prm_json_loader import PrmJsonLoader
+
+
+def serialize_statement(stmt: StatementData) -> bytes:
+    """converts a StatementData object into bytes that the FpySequencer can read"""
+    # see https://github.com/nasa/fprime/issues/3023#issuecomment-2693051677
+    # TODO replace this with actual documentation
+
+    # type: U8 (0 if directive, 1 if cmd)
+    # opcode: FwOpcodeType (default U32)
+    # argBufSize: FwSizeStoreType (default U16)
+    # argBuf: X bytes
+
+    output = bytes()
+    output += U8Type(stmt.template.statement_type.value).serialize()
+    output += get_type_obj_for("FwOpcodeType")(stmt.template.opcode).serialize()
+
+    arg_bytes = bytes()
+    for arg in stmt.arg_values:
+        arg_bytes += arg.serialize()
+
+    output += get_type_obj_for("FwSizeStoreType")(len(arg_bytes)).serialize()
+    output += arg_bytes
+
+    return output
+
+
+def parse_str_as_statement(
+    stmt: str, templates: list[StatementTemplate], context: BytecodeParseContext
+) -> StatementData:
+    """Converts a human-readable line of bytecode into a StatementData instance, given a list of
+    possible statement templates"""
+    name = stmt.split()[0]
+    args = stmt[len(name) :]
+
+    args = json.loads("[" + args + "]")
+
+    matching_template = [t for t in templates if t.name == name]
+    if len(matching_template) != 1:
+        # no unique match
+        if len(matching_template) == 0:
+            raise RuntimeError("Could not find command or directive " + str(name))
+        raise RuntimeError(
+            "Found multiple commands or directives with name " + str(name)
+        )
+    matching_template = matching_template[0]
+
+    arg_values = []
+    if len(args) < len(matching_template.args):
+        raise RuntimeError(
+            "Missing arguments for statement "
+            + str(matching_template.name)
+            + ": "
+            + str(matching_template.args[len(args) :])
+        )
+    if len(args) > len(matching_template.args):
+        raise RuntimeError(
+            "Extra arguments for"
+            + str(matching_template.name)
+            + ": "
+            + str(args[len(matching_template.args) :])
+        )
+    for index, arg_json in enumerate(args):
+        arg_type = matching_template.args[index]
+        if inspect.isclass(arg_type):
+            # it's a type. instantiate it with the json
+            arg_value = arg_type(arg_json)
+        else:
+            # it's a function. give it the json and the ctx
+            arg_value = arg_type(arg_json, context)
+        arg_values.append(arg_value)
+
+    return StatementData(matching_template, arg_values)
+
+
+def main():
+    arg_parser = ArgumentParser()
+    arg_parser.add_argument(
+        "input", type=Path, help="The path to the input .fpybc file"
+    )
+
+    arg_parser.add_argument(
+        "-d",
+        "--dictionary",
+        type=Path,
+        help="The JSON topology dictionary to compile against",
+        required=True,
+    )
+
+    arg_parser.add_argument(
+        "-o",
+        "--output",
+        type=Path,
+        help="The output .bin file path. Defaults to the input file path with a .bin extension",
+        default=None,
+    )
+
+    args = arg_parser.parse_args()
+
+    if not args.input.exists():
+        print("Input file", args.input, "does not exist")
+        exit(1)
+
+    if not args.dictionary.exists():
+        print("Dictionary file", args.dictionary, "does not exist")
+        exit(1)
+
+    serialize_bytecode(args.input, args.dictionary, args.output)
+
+
+def serialize_bytecode(input: Path, dictionary: Path, output: Path = None):
+    """Given an input .fpybc file, and a dictionary .json file, converts the
+    bytecode file into binary and writes it to the output file. If the output file
+    is None, writes it to the input file with a .bin extension"""
+    cmd_json_dict_loader = CmdJsonLoader(str(dictionary))
+    (_, cmd_name_dict, _) = cmd_json_dict_loader.construct_dicts(
+        str(dictionary)
+    )
+
+    stmt_templates = []
+    stmt_templates.extend(FPY_DIRECTIVES)
+    for cmd_template in cmd_name_dict.values():
+        stmt_template = StatementTemplate(
+            StatementType.CMD,
+            cmd_template.opcode,
+            cmd_template.get_full_name(),
+            [arg[2] for arg in cmd_template.arguments],
+        )
+        stmt_templates.append(stmt_template)
+
+    tlm_json_loader = ChJsonLoader(str(dictionary))
+    (_, tlm_name_dict, _) = tlm_json_loader.construct_dicts(
+        str(dictionary)
+    )
+
+    prm_json_loader = PrmJsonLoader(str(dictionary))
+    (_, prm_name_dict, _) = prm_json_loader.construct_dicts(
+        str(dictionary)
+    )
+
+    context = BytecodeParseContext()
+    context.types = cmd_json_dict_loader.parsed_types
+    context.channels = tlm_name_dict
+    context.params = prm_name_dict
+
+    input_lines = input.read_text().splitlines()
+    input_lines = [line.strip() for line in input_lines]
+    # remove comments and empty lines
+    input_lines = [
+        line for line in input_lines if not line.startswith(";") and len(line) > 0
+    ]
+
+    goto_tags = {}
+    stmt_idx = 0
+    statement_strs: list[str] = []
+    for stmt in input_lines:
+        if stmt.endswith(":"):
+            # it's a goto tag
+            goto_tags[stmt[:-1]] = stmt_idx
+        else:
+            statement_strs.append(stmt)
+            stmt_idx += 1
+
+    context.goto_tags = goto_tags
+
+    statements: list[StatementData] = []
+    for stmt_idx, stmt in enumerate(statement_strs):
+        try:
+            stmt_data = parse_str_as_statement(stmt, stmt_templates, context)
+            statements.append(stmt_data)
+        except BaseException as e:
+            raise RuntimeError(
+                "Exception while parsing statement index " + str(stmt_idx) + ": " + stmt
+            ) from e
+
+    # perform some checks for things we know will fail
+    for stmt in statements:
+        if stmt.template.name == "GOTO":
+            if stmt.arg_values[0].val > len(statements):
+                raise RuntimeError(
+                    f"GOTO index is outside the valid range for this sequence (was {stmt.arg_values[0].val}, should be <{len(statements)})"
+                )
+
+    output_bytes = bytes()
+
+    for stmt in statements:
+        output_bytes += serialize_statement(stmt)
+
+    header = Header(0, 0, 0, 1, 0, len(statements), len(output_bytes))
+    output_bytes = struct.pack(HEADER_FORMAT, *astuple(header)) + output_bytes
+
+    crc = zlib.crc32(output_bytes) % (1 << 32)
+    footer = Footer(crc)
+    output_bytes += struct.pack(FOOTER_FORMAT, *astuple(footer))
+
+    if output is None:
+        output = input.with_suffix(".bin")
+
+    output.write_bytes(output_bytes)
+
+
+if __name__ == "__main__":
+    main()

fprime_gds/common/fpy/types.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from enum import Enum
+import struct
+from typing import Any, Callable
+from fprime.common.models.serialize.type_base import BaseType, ValueType
+from fprime.common.models.serialize.time_type import TimeType
+from fprime.common.models.serialize.numerical_types import U32Type, U16Type, U8Type
+from fprime.common.models.serialize.string_type import StringType
+
+from fprime_gds.common.loaders.json_loader import PRIMITIVE_TYPE_MAP
+from fprime_gds.common.templates.ch_template import ChTemplate
+from fprime_gds.common.templates.prm_template import PrmTemplate
+
+
+def get_type_obj_for(type: str) -> type[ValueType]:
+    if type == "FwOpcodeType":
+        return U32Type
+    elif type == "FwSizeStoreType":
+        return U16Type
+    elif type == "FwChanIdType":
+        return U32Type
+    elif type == "FwPrmIdType":
+        return U32Type
+
+    raise RuntimeError("Unknown FPrime type alias " + str(type))
+
+
+class StatementType(Enum):
+    DIRECTIVE = 0
+    CMD = 1
+
+
+@dataclass
+class StatementTemplate:
+    """a statement with unspecified argument values"""
+
+    statement_type: StatementType
+    opcode: int
+    name: str
+    """fully qualified statement name"""
+    args: list[type[BaseType] | Callable[[Any, BytecodeParseContext], BaseType]]
+    """list of argument types of this statement, or functions that return an arg type"""
+
+
+@dataclass
+class StatementData:
+    template: StatementTemplate
+    arg_values: list[BaseType]
+
+
+HEADER_FORMAT = "!BBBBBHI"
+HEADER_SIZE = struct.calcsize(HEADER_FORMAT)
+
+
+@dataclass
+class Header:
+    majorVersion: int
+    minorVersion: int
+    patchVersion: int
+    schemaVersion: int
+    argumentCount: int
+    statementCount: int
+    bodySize: int
+
+
+FOOTER_FORMAT = "!I"
+FOOTER_SIZE = struct.calcsize(FOOTER_FORMAT)
+
+
+@dataclass
+class Footer:
+    crc: int
+
+
+class DirectiveOpcode(Enum):
+    INVALID = 0x00000000
+    WAIT_REL = 0x00000001
+    WAIT_ABS = 0x00000002
+    SET_LVAR = 0x00000003
+    GOTO = 0x00000004
+    IF = 0x00000005
+    NO_OP = 0x00000006
+    GET_TLM = 0x00000007
+    GET_PRM = 0x00000008
+
+
+@dataclass
+class BytecodeParseContext:
+    goto_tags: map[str, int] = field(default_factory=dict)
+    """a map of tag name with tag statement index"""
+    types: map[str, type[BaseType]] = field(default_factory=dict)
+    """a map of name to all parsed types available in the dictionary"""
+    channels: map[str, ChTemplate] = field(default_factory=dict)
+    """a map of name to ChTemplate object for all tlm channels"""
+    params: map[str, PrmTemplate] = field(default_factory=dict)
+    """a map of name to PrmTemplate object for all prms"""
+
+
+def time_type_from_json(js, ctx: BytecodeParseContext):
+    return TimeType(js["time_base"], js["time_context"], js["seconds"], js["useconds"])
+
+
+def arbitrary_type_from_json(js, ctx: BytecodeParseContext):
+    type_name = js["type"]
+
+    if type_name == "string":
+        # by default no max size restrictions in the bytecode
+        return StringType.construct_type(f"String", None)(js["value"])
+
+    # try first checking parsed_types, then check primitive types
+    type_class = ctx.types.get(type_name, PRIMITIVE_TYPE_MAP.get(type_name, None))
+    if type_class is None:
+        raise RuntimeError("Unknown type " + str(type_name))
+
+    return type_class(js["value"])
+
+
+def goto_tag_or_idx_from_json(js, ctx: BytecodeParseContext):
+    if isinstance(js, str):
+        # it's a tag
+        if js not in ctx.goto_tags:
+            raise RuntimeError("Unknown goto tag " + str(js))
+        return U32Type(ctx.goto_tags[js])
+
+    # otherwise it is a statement index
+    return U32Type(js)
+
+
+def tlm_chan_id_from_json(js, ctx: BytecodeParseContext):
+    if isinstance(js, str):
+        if js not in ctx.channels:
+            raise RuntimeError("Unknown telemetry channel " + str(js))
+        return get_type_obj_for("FwChanIdType")(ctx.channels[js].id)
+    elif isinstance(js, int):
+        matching = [tmp for tmp in ctx.channels.keys() if tmp.id == js]
+        if len(matching) != 1:
+            if len(matching) == 0:
+                raise RuntimeError("Unknown telemetry channel id " + str(js))
+            raise RuntimeError("Multiple matches for telemetry channel id " + str(js))
+        matching = matching[0]
+        return get_type_obj_for("FwChanIdType")(matching.id)
+
+
+def prm_id_from_json(js, ctx: BytecodeParseContext):
+    if isinstance(js, str):
+        if js not in ctx.params:
+            raise RuntimeError("Unknown parameter " + str(js))
+        return get_type_obj_for("FwPrmIdType")(ctx.params[js].prm_id)
+    elif isinstance(js, int):
+        matching = [tmp for tmp in ctx.params.keys() if tmp.prm_id == js]
+        if len(matching) != 1:
+            if len(matching) == 0:
+                raise RuntimeError("Unknown param id " + str(js))
+            raise RuntimeError("Multiple matches for param id " + str(js))
+        matching = matching[0]
+        return get_type_obj_for("FwPrmIdType")(matching.prm_id)
+
+
+FPY_DIRECTIVES: list[StatementTemplate] = [
+    StatementTemplate(
+        StatementType.DIRECTIVE,
+        DirectiveOpcode.WAIT_REL.value,
+        "WAIT_REL",
+        [U32Type, U32Type],
+    ),
+    StatementTemplate(
+        StatementType.DIRECTIVE,
+        DirectiveOpcode.WAIT_ABS.value,
+        "WAIT_ABS",
+        [time_type_from_json],
+    ),
+    StatementTemplate(
+        StatementType.DIRECTIVE,
+        DirectiveOpcode.SET_LVAR.value,
+        "SET_LVAR",
+        [U8Type, arbitrary_type_from_json],
+    ),
+    StatementTemplate(
+        StatementType.DIRECTIVE,
+        DirectiveOpcode.GOTO.value,
+        "GOTO",
+        [goto_tag_or_idx_from_json],
+    ),
+    StatementTemplate(
+        StatementType.DIRECTIVE,
+        DirectiveOpcode.IF.value,
+        "IF",
+        [U8Type, goto_tag_or_idx_from_json],
+    ),
+    StatementTemplate(
+        StatementType.DIRECTIVE,
+        DirectiveOpcode.GET_TLM.value,
+        "GET_TLM",
+        [U8Type, U8Type, tlm_chan_id_from_json],
+    ),
+    StatementTemplate(
+        StatementType.DIRECTIVE,
+        DirectiveOpcode.GET_PRM.value,
+        "GET_PRM",
+        [U8Type, prm_id_from_json],
+    ),
+]

fprime_gds/common/gds_cli/base_commands.py

@@ -130,7 +130,7 @@ class BaseCommand(abc.ABC):
             passes the given filter
         """
         project_dictionary = Dictionaries()
-        project_dictionary.load_dictionaries(dictionary_path, packet_spec=None)
+        project_dictionary.load_dictionaries(dictionary_path, packet_spec=None, packet_set_name=None)
         items = cls._get_item_list(project_dictionary, search_filter)
         return cls._get_item_list_string(items, json)