uphy-upgen 1.0.0__tar.gz

uphy_upgen-1.0.0/LICENSE.txt

@@ -0,0 +1,5 @@
+Copyright rt-labs AB, Sweden.
+All rights reserved.
+
+You may not use this software in a commercial product without
+purchasing a license. Contact sales@rt-labs.com for more information.

uphy_upgen-1.0.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.3
+Name: uphy-upgen
+Version: 1.0.0
+Summary: U-Phy Generator
+License: Copyright rt-labs AB, Sweden.
+         All rights reserved.
+         
+         You may not use this software in a commercial product without
+         purchasing a license. Contact sales@rt-labs.com for more information.
+Author: RT-Labs
+Author-email: support@rt-labs.com
+Requires-Python: >=3.8
+Classifier: License :: Other/Proprietary License
+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
+Provides-Extra: compile
+Provides-Extra: dev
+Requires-Dist: crc8 (>=0.2.0,<1.0.0)
+Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
+Requires-Dist: nuitka (>=2.4.11,<3.0.0) ; extra == "compile"
+Requires-Dist: pydantic (>=1.10.7,<2.0.0)
+Requires-Dist: pytest (>=7.4.4,<8.0.0) ; extra == "dev"
+Requires-Dist: pytest-cov (>=5.0.0,<6.0.0) ; extra == "dev"
+Requires-Dist: xmlschema (>=3.0.1,<4.0.0)
+Project-URL: Documentation, https://docs.rt-labs.com/u-phy
+Project-URL: RT-Labs, https://rt-labs.com/
+Project-URL: U-Phy, https://rt-labs.com/u-phy
+Description-Content-Type: text/markdown
+
+# U-Phy Device Generator
+
+The U-Phy Device Generator is a tool designed to create fieldbus
+device description files and U-Phy source code directly from device
+models generated by the U-Phy Device Builder.
+
+Maintaining synchronization between source code and description files
+can be challenging. Therefore, having a tool that generates both from
+a single source of truth is extremely beneficial.
+
+## Developing
+
+Python Poetry is recommended. See
+https://python-poetry.org/docs/#installation for installation
+instructions.
+
+    $ cd /path/to/upgen
+    $ poetry install
+    $ poetry shell
+

uphy_upgen-1.0.0/README.md

@@ -0,0 +1,19 @@
+# U-Phy Device Generator
+
+The U-Phy Device Generator is a tool designed to create fieldbus
+device description files and U-Phy source code directly from device
+models generated by the U-Phy Device Builder.
+
+Maintaining synchronization between source code and description files
+can be challenging. Therefore, having a tool that generates both from
+a single source of truth is extremely beneficial.
+
+## Developing
+
+Python Poetry is recommended. See
+https://python-poetry.org/docs/#installation for installation
+instructions.
+
+    $ cd /path/to/upgen
+    $ poetry install
+    $ poetry shell

uphy_upgen-1.0.0/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "uphy-upgen"
+version = "1.0.0"
+description = "U-Phy Generator"
+readme = "README.md"
+license = {file = "LICENSE.txt"}
+authors = [
+    {name="RT-Labs", email="support@rt-labs.com"}
+]
+requires-python = ">=3.8"
+
+dependencies = [
+    "pydantic (>=1.10.7,<2.0.0)",
+    "jinja2 (>=3.1.2,<4.0.0)",
+    "crc8 (>=0.2.0,<1.0.0)",
+    "xmlschema (>=3.0.1,<4.0.0)",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest (>=7.4.4,<8.0.0)",
+    "pytest-cov (>=5.0.0,<6.0.0)"
+]
+compile = [
+    "nuitka (>=2.4.11,<3.0.0)"
+]
+
+[project.scripts]
+upgen = 'upgen.cli:run'
+
+[project.urls]
+"RT-Labs" = "https://rt-labs.com/"
+"U-Phy" = "https://rt-labs.com/u-phy"
+"Documentation" = "https://docs.rt-labs.com/u-phy"
+
+[tool.poetry]
+packages = [
+    { include = "upgen" },
+]
+requires-poetry = ">=2.0"
+
+[tool.pytest.ini_options]
+addopts = "--cov=upgen --cov-report term-missing"
+
+[build-system]
+requires = ["poetry-core>=2.0"]
+build-backend = "poetry.core.masonry.api"

uphy_upgen-1.0.0/upgen/__init__.py

@@ -0,0 +1,16 @@
+import sys
+
+if sys.version_info[:2] >= (3, 8):
+    # TODO: Import directly (no need for conditional) when `python_requires = >= 3.8`
+    from importlib.metadata import PackageNotFoundError, version  # pragma: no cover
+else:
+    from importlib_metadata import PackageNotFoundError, version  # pragma: no cover
+
+try:
+    # Change here if project is renamed and does not equal the package name
+    dist_name = "uphy-upgen"
+    __version__ = version(dist_name)
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "unknown"
+finally:
+    del version, PackageNotFoundError

uphy_upgen-1.0.0/upgen/cli.py

@@ -0,0 +1,150 @@
+import argparse
+import logging
+import sys
+import os
+import traceback
+from argparse import RawTextHelpFormatter
+
+from pathlib import Path
+from json.decoder import JSONDecodeError
+from pydantic import ValidationError
+
+from upgen import __version__
+from upgen.model import *
+from upgen.generators import EtherCATGenerator
+from upgen.generators import ProfinetGenerator
+from upgen.generators import EthernetipGenerator
+from upgen.generators import CCodeGenerator
+from upgen.generators import SIIGenerator
+
+_logger = logging.getLogger(__name__)
+
+GENERATORS = {
+    'EtherCAT': EtherCATGenerator,
+    'Profinet': ProfinetGenerator,
+    "EtherNetIP":EthernetipGenerator,
+        'Code': CCodeGenerator,
+         'SII': SIIGenerator,
+
+}
+
+
+def get_generator_classes(name):
+    if name == 'All':
+        return [GENERATORS[g] for g in GENERATORS]
+    try:
+        return [GENERATORS[name]]
+    except KeyError:
+        raise ValueError(f"--generator name must be in {tuple(GENERATORS)} or \'All\')")
+
+
+def parse_args(args):
+    parser = argparse.ArgumentParser(description=
+    """
+    Tool for generation of device artifacts from a U-Phy device model
+    file, including:
+    - C-code with the device specific data model
+    - EtherCAT ESI file
+    - EtherCAT SII EEPROM file
+    - Profinet GSDML file
+
+    To evaluate the device functionality, copy generated model.c/h and
+    eeprom.bin to the \'generated\' folder of the U-Phy sample application
+    and rebuild.
+
+    Example usage:
+        upgen export my_device_model.json
+    """,
+    formatter_class=RawTextHelpFormatter)
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"upgen {__version__}",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        dest="loglevel",
+        help="set loglevel to INFO",
+        action="store_const",
+        const=logging.INFO,
+    )
+    parser.add_argument(
+        "-vv",
+        "--very-verbose",
+        dest="loglevel",
+        help="set loglevel to DEBUG",
+        action="store_const",
+        const=logging.DEBUG,
+    )
+    parser.add_argument("-d", "--destination", help="destination folder for generated model", default=".")
+
+    parser.add_argument('--generator', help="the generator to use. Option value "
+                        "can be one of  {} or \'All\'. Default value is \'All\'".format(tuple(GENERATORS)), default="All")
+
+    parser.add_argument('-n', '--device_name', help="the name of the device to generate. "
+                        "Only used when generating C code or SII eeprom for multi device models.")
+
+    # Import device description file or
+    # Export source code and device description files from json model
+    # TODO - for export the generators for fieldbuses defined by the
+    # model should be run. All outputs placed in the destination folder.
+    parser.add_argument('action', choices=('import', 'export', 'schema'))
+    parser.add_argument("file", help="Device model in JSON format")
+
+    return parser.parse_args(args)
+
+
+def setup_logging(loglevel):
+    logformat = "[%(asctime)s] %(levelname)s:%(name)s:%(message)s"
+    if loglevel is None:
+        loglevel = logging.WARNING
+    logging.basicConfig(
+        level=loglevel, stream=sys.stdout, format=logformat, datefmt="%Y-%m-%d %H:%M:%S"
+    )
+
+
+def main(args):
+    args = parse_args(args)
+    setup_logging(args.loglevel)
+
+    if args.action == 'import':
+        raise Exception( "import not supported")
+        generator_class = get_generator_class(args.generator)
+        generator = generator_class(None)
+        generator.import_file(args.file)
+        print(generator.model)
+
+    elif args.action == 'export':
+        try:
+            model = Root.parse_file(Path(args.file))
+        except (JSONDecodeError, ValidationError) as e:
+            print(e)
+            sys.exit(1)
+
+        os.makedirs(args.destination, exist_ok=True)
+        os.chdir(args.destination)
+        generator_classes = get_generator_classes(args.generator)
+        for gen_cls in generator_classes:
+            try:
+                generator = gen_cls(model)
+                if (gen_cls in [CCodeGenerator, SIIGenerator, EthernetipGenerator]):
+                    generator.select_device(args.device_name)
+                generator.export_file()
+            except Exception as e:
+                print(
+                    f"Error while running {gen_cls.__name__}: \"{str(e)}\" Continue generating rest of artifacts.")
+                _logger.warning(''.join(traceback.TracebackException.from_exception(e).format()))
+
+    elif args.action == 'schema':
+        print(Root.schema_json(indent=2))
+
+    _logger.info("Script ends here")
+
+
+def run():
+    main(sys.argv[1:])
+
+
+if __name__ == "__main__":
+    run()

uphy_upgen-1.0.0/upgen/generators/__init__.py

@@ -0,0 +1,11 @@
+
+# import os
+from pathlib import Path, PurePath
+
+SCHEMA_DIR = Path(PurePath(__file__).parent, "schema")
+
+from .ethercat import EtherCATGenerator
+from .sii import SIIGenerator
+from .profinet import ProfinetGenerator
+from .ethernetip import EthernetipGenerator
+from .c_code import CCodeGenerator

uphy_upgen-1.0.0/upgen/generators/c_code.py

@@ -0,0 +1,247 @@
+import logging
+import re
+import json
+import importlib.resources
+from .. import templates
+from jinja2 import Environment, PackageLoader, select_autoescape
+from ..model.uphy import *
+
+_logger = logging.getLogger(__name__)
+
+
+def c_type(value):
+    map = {
+        DataType.UINT32: 'uint32_t',
+        DataType.UINT16: 'uint16_t',
+        DataType.UINT8: 'uint8_t',
+        DataType.INT32: 'int32_t',
+        DataType.INT16: 'int16_t',
+        DataType.INT8: 'int8_t',
+        DataType.REAL32: 'float',
+    }
+    return map[value.datatype]
+
+class CNameContext():
+    """
+    Defines scopes for identifiers:
+    - Slots
+        - Signals/Parameters (per slot)
+    - Modules
+    - Alarms
+    """
+    class Scope(Enum):
+        NONE = 0,
+        SLOT = 1,
+        SIGNAL = 2,
+        MODULE = 3,
+        ALARM = 4,
+        TXPDO = 5,
+        RXPDO = 6
+
+    def __init__(self, slot=""):
+        self.slot = slot
+        self.scope = self.Scope.NONE
+        self.ctx = {
+            self.Scope.SLOT: {},    # (name, index)
+            self.Scope.SIGNAL: {},  # {slot_index: (name, index)}
+            self.Scope.MODULE: {},  # (name, index)
+            self.Scope.ALARM: {},   # (name, index)
+            self.Scope.TXPDO: {},   # (name, index)
+            self.Scope.RXPDO: {},   # (name, index)
+        }
+
+    def _get_ctx(self):
+        assert self.ctx != self.Scope.NONE
+
+        if self.Scope == self.Scope.SIGNAL:
+            assert self.slot != ""
+            if self.slot not in self.ctx[self.scope]:
+                self.ctx[self.scope][self.slot] = {}
+
+            ctx = self.ctx[self.scope][self.slot]
+        else:
+            ctx = self.ctx[self.scope]
+
+        return ctx
+
+    def name_available(self, name, index):
+        ctx = self._get_ctx()
+
+        for other_index, other_name in ctx.items():
+            if name == other_name and index != other_index:
+                _logger.debug(f"[{self.scope}] name collision: {name}, '{index}' '{other_index}'")
+                return False
+
+        return True
+
+    def set_name(self, name, index):
+        ctx = self._get_ctx()
+        ctx[index] = name
+
+    def get_name(self, index):
+        ctx = self._get_ctx()
+        return ctx.get(index, None)
+
+    def index_exists(self, index):
+        ctx = self._get_ctx()
+        return index in ctx
+
+    def new_unique_name(self, name, index):
+        if self.index_exists(index):
+            name = self.get_name(index)
+        else:
+            while not self.name_available(name, index):
+                name += "_" + str(index)
+
+            # Store name for future calls
+            self.set_name(name, index)
+
+            _logger.debug(f"c_name: {name} allocated to index '{index}'")
+
+        return name
+
+def c_name(value, index, ctx, scope):
+    """
+    Filter for C names. An index should be included to avoid duplicate
+    names and ensure consistency across repeated calls. For example:
+        {{slot | c_name(loop.index0, ctx, ctx.Scope.SLOT)}}
+        {{signal | c_name("in_" ~ loop.index0, ctx, ctx.Scope.SIGNAL)}}
+
+    Valid scopes are defined by the enum ctx.Scope (except NONE):
+    - ctx.Scope.SLOT
+        - ctx.Scope.SIGNAL (NOTE: requires previous call with scope SLOT)
+    - ctx.Scope.MODULE
+    - ctx.Scope.ALARM
+    - ctx.Scope.TXPDO
+    - ctx.Scope.RXPDO
+
+    Note that the SIGNAL scope is shared by inputs, outputs and parameters.
+    """
+    name = value.name
+    if re.search("^[0-9].*", name):           # Escape leading numeral
+        name = f"_{name}"
+
+    name = re.sub("[^0-9A-Za-z_]", "_", name) # Replace special chars
+    name = re.sub("_+", "_", name)            # Contract repeating underscore
+    if name != "_":
+        name = re.sub("_$", "", name)         # Strip trailing underscore
+
+    # Set scope
+    ctx.scope = scope
+    if scope == ctx.Scope.SLOT:
+        ctx.slot = index                      # Define signal scope
+
+    name = ctx.new_unique_name(name, index)   # Ensure name is unique
+
+    return name
+
+
+def c_name_upper(value, index, ctx, scope):
+    """Filter for uppercase C names. For example defines."""
+    return c_name(value, index, ctx, scope).upper()
+
+
+def c_hex(value):
+    return value.replace('#', '0')
+
+def c_array(signal):
+    if not signal.is_array:
+        return ""
+    else:
+        return f"[{signal.array_length}]"
+
+def c_flags(signal):
+    if not signal.is_array:
+        return "0"
+    else:
+        return "UP_SIG_FLAG_IS_ARRAY"
+
+def c_bool(value):
+    if value:
+        return "true"
+    else:
+        return "false"
+
+# str.__repr__ never escapes double quotes:
+# - print(("\"").__repr__())        => '"'
+# - print(("\"" + '\'').__repr__()) => '\'"'
+# Backslashes also need to appear escaped when output.
+def c_string(s):
+    if s:
+        s = s.replace("\\", "\\\\")
+        s = s.replace('"', r'\"')
+    return s
+
+# str.__repr__ only escapes single quotes if there is also a
+# double quote in the string:
+# - print(('\'').__repr__())        => "'"
+# - print(("\"" + '\'').__repr__()) => '\'"'
+# For C chars an extra backslash therefore needs to be added.
+def c_char(s):
+    if s:
+        s = s.replace("'", r"\'")
+    return s
+
+def enip_major_rev(rev_str):
+    return rev_str.split('.')[0]
+
+def enip_minor_rev(rev_str):
+    return rev_str.split('.')[1]
+
+class CCodeGenerator:
+    def __init__(self, model):
+        self.model = model
+        self.device = None
+        self.name_ctx = CNameContext()
+
+        self.env = Environment(
+            loader=PackageLoader("upgen"),
+            autoescape=select_autoescape(),
+            trim_blocks=True,
+            lstrip_blocks=True
+        )
+        self.env.filters['c_type'] = c_type
+        self.env.filters['c_name'] = c_name
+        self.env.filters['c_hex'] = c_hex
+        self.env.filters['c_name_upper'] = c_name_upper
+        self.env.filters['c_array'] = c_array
+        self.env.filters['c_flags'] = c_flags
+        self.env.filters['c_bool'] = c_bool
+        self.env.filters['c_string'] = c_string
+        self.env.filters['c_char'] = c_char
+        self.env.filters['enip_major_rev'] = enip_major_rev
+        self.env.filters['enip_minor_rev'] = enip_minor_rev
+        self.env.globals['ctx'] = self.name_ctx
+
+    def select_device(self, device_name):
+        if device_name == None:
+            self.device = self.model.devices[0]
+        else:
+            self.device = self.model.get_device(device_name)
+
+        if self.device == None:
+            raise Exception(f'{device_name} not found in model')
+
+    def export_file(self):
+        _logger.info('Generate model.h')
+        header = self.generate_header_file()
+        _logger.info('Generate model.c')
+        source = self.generate_source_file()
+
+        with open('model.h', 'w') as file:
+            file.write(header)
+
+        with open('model.c', 'w') as file:
+            file.write(source)
+
+    def generate_header_file(self):
+        template = self.env.get_template("model_template.h")
+        code = template.render(model=self.model, device=self.device)
+        _logger.debug(code)
+        return code
+
+    def generate_source_file(self):
+        template = self.env.get_template("model_template.c")
+        code = template.render(model=self.model, device=self.device)
+        _logger.debug(code)
+        return code