From 1126e5d3561263718ac3cefb223b57fb43777432 Mon Sep 17 00:00:00 2001 From: Joshua Lucas Date: Wed, 14 Oct 2026 21:16:40 -0500 Subject: [PATCH] Split iec.py into submodules; add iec_address submodule. --- src/AuDaGe/iec/__init__.py | 13 ++ src/AuDaGe/iec/iec_address.py | 325 ++++++++++++++++++++++++++ src/AuDaGe/iec/iec_common.py | 64 ++++++ src/AuDaGe/iec/iec_type.py | 419 ++++++++++++++++++++++++++++++++++ tests/test_iec.py | 216 +++++++++++++++++- 5 files changed, 1026 insertions(+), 11 deletions(-) create mode 100644 src/AuDaGe/iec/__init__.py create mode 100644 src/AuDaGe/iec/iec_address.py create mode 100644 src/AuDaGe/iec/iec_common.py create mode 100644 src/AuDaGe/iec/iec_type.py diff --git a/src/AuDaGe/iec/__init__.py b/src/AuDaGe/iec/__init__.py new file mode 100644 index 0000000..944a277 --- /dev/null +++ b/src/AuDaGe/iec/__init__.py @@ -0,0 +1,13 @@ +""" +AuDaGe IEC module init + +name: __init__.py +by: Josh Lucas +date: 2026-10-14 + +desc: Definitions for IEC 61131 programming paradigms. +""" + +from .iec_address import * +from .iec_common import * +from .iec_type import * diff --git a/src/AuDaGe/iec/iec_address.py b/src/AuDaGe/iec/iec_address.py new file mode 100644 index 0000000..be1ba06 --- /dev/null +++ b/src/AuDaGe/iec/iec_address.py @@ -0,0 +1,325 @@ +""" +AuDaGe IEC Address submodule + +name: iec.py +by: Josh Lucas +date: 2026-10-14 + +desc: Definitions for IEC 61131 address paradigms. +""" + +import copy +import operator +import re +from collections.abc import Callable +from enum import StrEnum, auto + +from .iec_common import * + +MAX_ADDRESS = 65535 + + +class AddressType(StrEnum): + I = auto() # Input + K = auto() # Module? + M = auto() # Memory + Q = auto() # Output + S = auto() # System + + +class AddressLength(StrEnum): + D = auto() # Double word + W = auto() # Word + X = auto() # Explicit bit + + +class Address: + """Class for manipulating IEC 61131-3 and Modbus addresses.""" + + # Constants + IEC_PATTERN = ( + r"^\s*" # Leading whitespace + r"%?([ikmsq])([dwx]?)" # Prefix + r"(\d{1,5})" # Register number + r"(?:\.(\d{0,2}))?" # Bit rank (optional) + r"\s*$" # Trailing whitespace + ) + + MODBUS_PATTERN = ( + r"^\s*" # Leading whitespace + r"(\d{1,6})" # Register number + r"(?:\.(\d{1,2}))?" # Bit rank (optional) + r"\s*$" # Trailing whitespace + ) + + # Dunder methods + def __init__( + self, + address_type: AddressType | str = AddressType.M, + address_length: AddressLength | str | None = AddressLength.W, + word: float | str = 0, + bit: int | str | None = None, + ): + """Initialize an IEC address object. + + Parameters + ---------- + address_type : AddressType | str + The type of IEC address. A member of AddressType or a string + corresponding to the name of one of the members. Default + AddressType.M. + address_length : AddressLength | str | None + The length of the IEC address memory location. None or X for + one-bit-length locations, W for word, or D for double word. Default + AddressLength.W. + word : float | str + The word part of the address number. An integer, float, or + string that one of the former. If a floatDefault 0. + bit : int | str | None + The bit part of the address number. None or empty string for + addresses with no bit part; integer or a string that converts to an + integer for addresses that do have a bit part. Default None. + """ + class_name = self.__class__.__name__ + if isinstance(address_type, str): + try: + self.address_type = AddressType.__members__[ + address_type.upper() + ] + except KeyError: + raise InvalidSpecError( + class_name, f"address type: {address_type.upper()}" + ) + else: + self.address_type = address_type + if isinstance(address_length, str): + try: + self.address_length = ( + AddressLength.__members__[address_length.upper()] + if address_length + else None + ) + except KeyError: + raise InvalidSpecError( + class_name, f"address length: {address_length.upper()}" + ) + else: + self.address_length = address_length + try: + bit_int = int(bit) + except TypeError, ValueError: + bit_int = None + word_float = float(word) + if word_float % 1 != 0 and bit_int is not None: + bit_int = int(word_float % 1 * 100) + word_int = int(word_float) + if word_int not in range(MAX_ADDRESS + 1): + raise InvalidSpecError( + class_name, + f"address word: {word_int}", + f"Address word must be between 0 and {MAX_ADDRESS}, inclusive.", + ) + self.word = word_int + if bit_int is not None and bit_int not in range(DataUnit.WORD): + raise InvalidSpecError( + class_name, + f"address bit: {bit}", + f"Address bit must be between 0 and {DataUnit.WORD - 1}, " + f"inclusive.", + ) + self.bit = bit_int + + def __add__(self, other: Address | float) -> Address: + return self._combine(other, operator.add) + + def __eq__(self, other: any) -> bool: + try: + return all( + self.__dict__[name] == other.__dict__[name] + for name in self.__dict__ + ) + except KeyError: + return False + + def __str__(self) -> str: + return self.to_string() + + def __sub__(self, other: Address | float) -> Address: + return self._combine(other, operator.sub) + + # Private methods + def _combine(self, other: Address | float, operator: Callable) -> Address: + """Common operations for adding and subtracting addresses.""" + address = copy.copy(self) + if isinstance(other, Address): + bit_add = other.bit + word_add = other.word + else: + word_add = other // 1 + bit_add = (other % 1) * 100 + if address.bit is None: + carry = 0 + else: + (carry, address.bit) = divmod( + operator(address.bit, bit_add), DataUnit.WORD + ) + address.word = operator(address.word, word_add + carry) + return address + + # Constructors + @classmethod + def from_string(cls, spec: str) -> Address: + """Create an Address object based on a string representation of an IEC + address. + """ + if isinstance(spec, Address): + return spec + try: + match = re.match(cls.IEC_PATTERN, spec, flags=re.IGNORECASE) + except TypeError: + match = None + print(spec) + if match is None: + raise InvalidSpecError(cls.__class__.__name__, spec) + return cls(*match.groups()) + + @classmethod + def from_modbus( + cls, spec: str | float, digits: int = 5, explicit_bit: bool = False + ) -> Address: + """Create an Address object based on a Modbus address. + + Parameters + ---------- + spec : str | float + Modbus address. + digits : int + Number of digits in the Modbus address format. Any spec with fewer + digits than this is assumed to have implied leading zeroes and + therefore be a 0x address. Note that this only affects the + interpretation of addresses with fewer than this number of digits. + Addresses with more than this number of digits are still interpreted + correctly. Default 5. + explicit_bit : bool + Whether to use the 'X' indication of a bit-length IEC address. + Default False. + """ + class_name = cls.__class__.__name__ + # Parse the Modbus address into word and bit parts. + if isinstance(spec, str): + match = re.match(cls.MODBUS_PATTERN, spec) + if match is None: + raise InvalidSpecError(class_name, spec) + word_init = match.group(1) + bit_init = match.group(2) + else: + word_init = str(spec // 1) + bit_init = None if isinstance(spec, int) else (spec % 1) * 100 + # Determine the address type and length. + if len(word_init) < digits or word_init.startswith("0"): + address_type = AddressType.M + address_length = AddressLength.X if explicit_bit else None + word = word_init + bit = None + else: + word = word_init[1:] + bit = bit_init + match word_init[0]: + case "1": + address_type = AddressType.I + address_length = AddressLength.X if explicit_bit else None + case "3": + address_type = AddressType.I + address_length = ( + AddressLength.X + if (bit and explicit_bit) + else AddressLength.W + ) + case "4": + address_type = AddressType.M + address_length = ( + AddressLength.X + if (bit and explicit_bit) + else AddressLength.W + ) + case _: + raise InvalidSpecError( + class_name, + spec, + "Modbus addresses must start with 0, 1, 3, or 4.", + ) + return cls(address_type, address_length, word, bit) + + # Other class methods + @classmethod + def is_iec(cls, spec: str) -> bool: + return re.match(cls.IEC_PATTERN, spec, flags=re.IGNORECASE) is not None + + @classmethod + def is_modbus(cls, spec: str) -> bool: + return ( + re.match(cls.MODBUS_PATTERN, spec, flags=re.IGNORECASE) is not None + ) + + # Instance methods + def is_even(self) -> bool: + return self.word % 2 == 0 and not self.bit + + def to_string(self, digits: int = 0) -> str: + """Output a string representation of the IEC address. If `digits` is + set, the output address will be padded with leading zeroes to acheive + the specified number of digits. + """ + return "".join( + ( + "%", + self.address_type.name, + self.address_length.name if self.address_length else "", + f"{int(self.word):0{digits}d}", + f".{int(self.bit):02d}" if self.bit or self.bit == 0 else "", + ) + ) + + def to_modbus(self, digits: int = 6) -> str: + """Output the closest Modbus equivalent of the IEC address as a string. + The parameter `digits` specifies the length of the output address + (default 6). Shorter addresses will have leading zeroes added to achieve + this length. + """ + if self.word >= 10 ** (digits - 1): + raise ValueError( + f"This IEC address ({self}) is too large to fit into a Modbus " + f"address with the specified number of digits ({digits})." + ) + if self.address_length is None: + if self.address_type == AddressType.M: + first_digit = "0" + elif self.address_type == AddressType.I: + first_digit = "1" + else: + raise ValueError( + f"This IEC address does not correspond to a valid " + f"Modbus address: {self}." + ) + else: + match (self.address_type, self.address_length): + case (AddressType.M, AddressLength.X): + first_digit = "0" + case (AddressType.I, AddressLength.X): + first_digit = "1" + case (AddressType.I, AddressLength.W): + first_digit = "3" + case (AddressType.M, AddressLength.W): + first_digit = "4" + case _: + raise ValueError( + f"This IEC address does not correspond to a valid " + f"Modbus address: %{self}." + ) + return "".join( + ( + first_digit, + f"{self.word:0{digits - 1}d}", + f".{self.bit:02d}" if self.bit else "", + ) + ) diff --git a/src/AuDaGe/iec/iec_common.py b/src/AuDaGe/iec/iec_common.py new file mode 100644 index 0000000..67fee31 --- /dev/null +++ b/src/AuDaGe/iec/iec_common.py @@ -0,0 +1,64 @@ +""" +AuDaGe IEC Common submodule + +name: iec_common.py +by: Josh Lucas +date: 2026-10-14 + +desc: Shared definitions for IEC 61131 programming paradigms. +""" + +from enum import IntEnum + + +class DataUnit(IntEnum): + """The length in bits of various data units.""" + + BIT = 1 + NIBBLE = 4 + BYTE = 8 + WORD = 16 + DWORD = 32 + QWORD = 64 + + +class DataUnitMismatchWarning(RuntimeWarning): + """The length of the data type is not evenly divisible by the selected + unit. + """ + + DEFAULT_MESSAGE = ( + "Data length is not evenly divisible by the selected unit. The length " + "will be rounded to the nearest unit by {round_function}()." + ) + + def __init__( + self, message: str | None = None, round_function: str = "math.ceil" + ): + self.message = self.DEFAULT_MESSAGE if message is None else message + super().__init__(self.message.format(round_function=round_function)) + + +class InvalidSpecError(ValueError): + """Error to be raised when an invalid specification is provided to Array or + String classes. + + Inherits from ValueError and implements a default message. + """ + + DEFAULT_MESSAGE = ( + "The provided {source} specification ({spec}) is not valid." + ) + + def __init__( + self, + source: str = "", + spec: str = "", + message: str = "", + *args, + **kwargs, + ): + self.message = " ".join( + (self.DEFAULT_MESSAGE.format(source=source, spec=spec), message) + ) + super().__init__(self.message, *args, **kwargs) diff --git a/src/AuDaGe/iec/iec_type.py b/src/AuDaGe/iec/iec_type.py new file mode 100644 index 0000000..afb4261 --- /dev/null +++ b/src/AuDaGe/iec/iec_type.py @@ -0,0 +1,419 @@ +""" +AuDaGe IEC Type submodule + +name: iec.py +by: Josh Lucas +date: 2026-10-14 + +desc: Definitions for IEC 61131 data type paradigms. +""" + +import re +import warnings +from collections.abc import Callable +from enum import IntFlag, StrEnum, auto +from math import ceil, prod + +import pandas as pd +from numpy import nan + +from AuDaGe.better_enum import AliasEnum, AliasEnumType +from AuDaGe.frame import AuDaGeFrame + +from .iec_common import * + +UNKNOWN_LENGTH = -1 + +type_iec_to_opcua = { + "BOOL": "Boolean", + "EBOOL": "Boolean", + "BYTE": "Byte", + "WORD": "Word", + "DWORD": "DWord", + "LWORD": "QWord", + "SINT": "Char", + "INT": "Short", + "DINT": "Long", + "LINT": "LongLong", + "USINT": "Byte", + "UINT": "Word", + "UDINT": "DWord", + "ULINT": "QWord", + "REAL": "Float", + "LREAL": "Double", + "DATE": "DWord", + "LDATE": "QWord", + "DT": "DWord", + "LDT": "QWord", + "TIME": "DWord", + "LTIME": "QWord", + "TOD": "DWord", + "LTOD": "QWord", + "CHAR": "Char", + "WCHAR": "Word", + "STRING": "String", +} + +type_opcua_to_iec = { + "Boolean": "BOOL", + "Byte": "BYTE", + "Word": "WORD", + "DWord": "DWORD", + "QWord": "LWORD", + "Char": "CHAR", + "Short": "INT", + "Long": "DINT", + "LongLong": "LINT", + "Float": "REAL", + "Double": "LREAL", + "String": "STRING", +} + + +class IECClass(StrEnum): + """Classes of IEC 61131-3 data types.""" + + BINARY = auto() + INTEGER = auto() + REAL = auto() + DATETIME = auto() + CHAR = auto() + ARRAY = auto() + UDT = auto() + + +class IECTypeFlag(IntFlag): + BINARY = auto() + INTEGER = auto() + REAL = auto() + DATE = auto() + TIME = auto() + DT = auto() + TOD = auto() + CHAR = auto() + UDT = auto() + BIT = auto() # 1-bit + SHORT = auto() # 8-bit + DOUBLE = auto() # 32-bit + LONG = auto() # 64-bit + STRING = auto() + ARRAY = auto() + + +class IECType: + """A representation of an IEC 61131-3 data type.""" + + def __init__( + self, + name: str, + iec_class: IECClass, + length: int = 0, + unit: DataUnit = DataUnit.BIT, + round_function: Callable[[float], int] = ceil, + ): + """Initialize an object representing an IEC 61131-3 elementary data + type. + + Parameters + ---------- + class : IECClass + The class of the data type (BINARY, INTEGER, etc.). + length : int + The length of the data type in the corresponding unit. One of these + must be provided. If several are provided, the first in the order + above takes priority. + unit : DataUnit + The data unit to use to measure the length of the data type. + Defaults to DataUnit.WORD. + round_function : Callable[[float], int] + The function to use to round the data length when it does not divide + evenly by the selected unit. Defaults to math.ceil(). + """ + self.name = name + self.iec_class = iec_class + self.round = round_function + self.length_bits = length * unit + self.length = self.get_length + + def get_length( + self, unit: DataUnit | int = DataUnit.BIT, silent: bool = False + ) -> int: + """Get the data length of the type in the specified unit.""" + if self.length_bits % unit != 0 and not silent: + warnings.warn(None, category=DataUnitMismatchWarning) + return int(self.round(self.length_bits / unit)) + + def set_length(self, value: int, unit: DataUnit = DataUnit.BIT): + """Set the data length of the type in the specified unit.""" + self.length_bits = value * unit + + def from_opcua(self, spec: str): + pass + + def to_opcua(self) -> str: + pass + + +class MetaElementaryTypes(AliasEnumType): + """Override some of the EnumType methods so that they include aliases.""" + + def __contains__(cls, name: str) -> bool: + """The default Enum __contains__ method does not include aliases. This + one does. + """ + return cls.contains(name, include_array=True, include_string=True) + + def contains( + cls, name: str, include_array: bool = True, include_string: bool = True + ) -> bool: + """Like __contains__ but provides options to include or exclude strings + and arrays from elementary types. + """ + if name.upper() in cls.__members__: + return True + try: + # If `name` is a valid array spec, return whether it is elementary + # or not. + return Array(name).is_elementary() and include_array + except InvalidSpecError: + pass + try: + String(name) + # The return below is only reached if String does not raise + # InvalidSpecError. + return include_string + except InvalidSpecError: + pass + return False + + +# Disable Ruff warnings about duplicate values in this enum. +class ElementaryTypes(AliasEnum, metaclass=MetaElementaryTypes): + """Dataclass of IEC 61131-3 elementary variable types.""" + + # Binary + BOOL = IECType("BOOL", IECClass.BINARY, 1) + EBOOL = IECType("EBOOL", IECClass.BINARY, 8) + BYTE = IECType("BYTE", IECClass.BINARY, 8) + WORD = IECType("WORD", IECClass.BINARY, 16) + DWORD = IECType("DWORD", IECClass.BINARY, 32) + LWORD = IECType("LWORD", IECClass.BINARY, 64) + # Signed Integer + SINT = IECType("SINT", IECClass.INTEGER, 8) + INT = IECType("INT", IECClass.INTEGER, 16) + DINT = IECType("DINT", IECClass.INTEGER, 32) + LINT = IECType("LINT", IECClass.INTEGER, 64) + # Unsigned Integer + USINT = IECType("USINT", IECClass.INTEGER, 8) + UINT = IECType("UINT", IECClass.INTEGER, 16) + UDINT = IECType("UDINT", IECClass.INTEGER, 32) + ULINT = IECType("ULINT", IECClass.INTEGER, 64) + # Float + REAL = IECType("REAL", IECClass.REAL, 32) + LREAL = IECType("LREAL", IECClass.REAL, 64) + # Date/Time + DATE = IECType("DATE", IECClass.DATETIME, 32) + LDATE = IECType("LDATE", IECClass.DATETIME, 64) + DT = IECType("DT", IECClass.DATETIME, 32) + LDT = IECType("LDT", IECClass.DATETIME, 64) + TIME = IECType("TIME", IECClass.DATETIME, 32) + LTIME = IECType("LTIME", IECClass.DATETIME, 64) + TOD = IECType("TOD", IECClass.DATETIME, 32) + LTOD = IECType("LTOD", IECClass.DATETIME, 64) + # Character + CHAR = IECType("CHAR", IECClass.CHAR, 8) + WCHAR = IECType("WCHAR", IECClass.CHAR, 16) + STRING = IECType("STRING", IECClass.CHAR, 128) + + +# ruff: enable[PIE796] + + +class Array(IECType): + """An IEC 61131-3 array data type variable.""" + + class ArraySpec: + # Regular expression for parsing array specifications. + SPEC_PATTERN = ( + # Array declaration: "arr(ay)" with variable whitespace before and + # after. + r"^\s*arr(?:ay)?\s*" + # Bounds: for each dimension of the array, a pair of integers + # separated by "..(.)", with each pair delimited by commas with + # variable whitespace. All enclosed in square brackets. + r"\[((?:\d+\s*\.{2,3}\s*\d+\s*,?\s*)+)\]" + # Data type: optional "of" with whitespace, a word, and variable + # whitespace at the end. + r"\s*(?:of\s+)?(\w+)\s*$" + ) + + # Regular expression that matches integers within the bounds section of + # an array specification. + BOUNDS_PATTERN = r"\d+" + + def __init__(self, spec: str): + class_name = self.__class__.__name__ + self.spec = spec + match = re.match(self.SPEC_PATTERN, spec, re.IGNORECASE) + # Check whether the regex matches at all. + if match is None: + raise InvalidSpecError(class_name, spec) + self.type_name = match.group(2) + all_bounds = re.findall( + self.BOUNDS_PATTERN, match.group(1), re.IGNORECASE + ) + # Group the bounds of the array into pairs. + self.bounds = list(zip(all_bounds[::2], all_bounds[1::2])) + # Check that each dimension's upper bound is greater than or equal + # to its lower bound. + try: + for lbound, ubound in self.bounds: + if int(lbound) > int(ubound): + raise InvalidSpecError( + class_name, + spec, + "The upper bound of at least one dimension is less " + "than its lower bound.", + ) + # ValueError is raised if the array bounds are not coercible to + # integers. + except ValueError: + raise InvalidSpecError( + class_name, + spec, + "At least one bound is not an integer.", + ) + + def __init__( + self, + spec: str, + round_function: Callable[[float], int] = ceil, + *args, + **kwargs, + ): + """Create an instance of Array based on an IEC 61131-3 array + specification as a string. For maximum compatibility should be of the + form "ARRAY [{bounds}] OF {TYPE}" where m and n are integers, m < n, + and TYPE is the name of an IEC 61131-3 data type. This function is + tolerant of some variation in the formatting of this specification and + is not case-sensitive. + """ + self.spec = self.ArraySpec(spec) + if not self.is_elementary(): + length_bits = -1 + else: + # Calculate the length of the array in bits. + length_bits = ( + prod( + (int(ubound) - int(lbound) + 1) + for (lbound, ubound) in self.spec.bounds + ) + * ElementaryTypes[self.spec.type_name.upper()].value.length_bits + ) + super().__init__( + spec, + IECClass.ARRAY, + length_bits, + DataUnit.BIT, + round_function, + *args, + **kwargs, + ) + + def is_elementary(self) -> bool: + return self.spec.type_name in ElementaryTypes + + def make_definition(self, name: str, comment: str = "") -> AuDaGeFrame: + dimensions = [ + int(ubound) - int(lbound) + 1 + for (lbound, ubound) in self.spec.bounds + ] + length = prod(dimensions) + all_indices = None + for i, (lbound, ubound) in enumerate(self.spec.bounds): + dim_indices = pd.Series( + range(int(lbound), int(ubound) + 1), name=f"dim{i}" + ) + if all_indices is None: + all_indices = pd.DataFrame(dim_indices) + continue + all_indices = all_indices.join(dim_indices, how="cross") + columns = {} + columns["name"] = pd.Series( + all_indices.apply( + lambda row: f"{name}[{','.join(str(dim) for dim in row)}]", + axis=1, + ), + name="name", + ) + columns["parent"] = pd.Series( + [self.spec.spec.upper()] * length, name="parent" + ) + columns["type"] = pd.Series([self.spec.type_name] * length, name="type") + columns["address"] = pd.Series( + [nan] * length, + name="address", + ) + columns["comment"] = pd.Series([comment] * length, name="comment") + return AuDaGeFrame(columns) + + +class String(IECType): + """An IEC 61131-3 string data type variable.""" + + STRING_SPEC_PATTERN = r"^\s*str(?:ing)?\s*\[(\d+)\]\s*$" + + def __init__(self, spec: str, *args, **kwargs): + """Create an instance of String based on an IEC 61131-3 string + specification as a string. For maximum compatibility should be of the + form "STRING [{n}]" where n is an integer. This function is tolerant of + some variation in the formatting of this specification and is not + case-sensitive. + """ + class_name = self.__class__.__name__ + match = re.match(self.STRING_SPEC_PATTERN, spec, re.IGNORECASE) + try: + length_bytes = int(match.group(1)) + if length_bytes <= 0: + raise InvalidSpecError( + class_name, + spec, + "The string length must be greater than zero.", + ) + except AttributeError, ValueError: + raise InvalidSpecError(class_name, spec) + super().__init__( + spec, IECClass.CHAR, length_bytes, DataUnit.BYTE, *args, **kwargs + ) + + +def get_data_length( + type_name: str, + unit: DataUnit = DataUnit.BIT, + udt_lengths: dict[str, int] | None = None, + round_function: Callable[[float], int] = ceil, + unknown_length: any = UNKNOWN_LENGTH, +) -> any: + """Get the length of the specified data type as measured in the specified + unit. Returns the value specified by `unknown_length` (default -1) if the + data type is unknown. + """ + try: + return udt_lengths[type_name] // unit + # TypeError is raised if udt_lengths is None; KeyError is raised if + # `type_name` does not exist in udt_lengths. + except TypeError, KeyError: + pass + try: + return ElementaryTypes[type_name].value.get_length(unit) + except KeyError: + pass + try: + return Array(type_name).get_length(unit) + except ValueError: + pass + try: + return String(type_name).get_length(unit) + except ValueError: + pass + return unknown_length diff --git a/tests/test_iec.py b/tests/test_iec.py index 6af4d5b..a027370 100644 --- a/tests/test_iec.py +++ b/tests/test_iec.py @@ -10,11 +10,9 @@ desc: Unit tests for the AuDaGe IEC module. import unittest import warnings -from importlib import resources +from importlib import resources # noqa: F401 from math import ceil, floor -import output - from AuDaGe.iec import * @@ -49,6 +47,200 @@ class TestIEC(unittest.TestCase): ) +class TestAddress(unittest.TestCase): + def setUp(self): + self.good_specs = ( + ( + "%MW300.04", + (AddressType.M, AddressLength.W, 300, 4), + "%MW300.04", + "%MW00300.04", + "400300.04", + ), + ( + "%MW300.4", + (AddressType.M, AddressLength.W, 300, 4), + "%MW300.04", + "%MW00300.04", + "400300.04", + ), + ( + "%IW65535.15", + (AddressType.I, AddressLength.W, 65535, 15), + "%IW65535.15", + "%IW65535.15", + "365535.15", + ), + ( + "%I12345", + (AddressType.I, None, 12345, None), + "%I12345", + "%I12345", + "112345", + ), + ( + "%M6440", + (AddressType.M, None, 6440, None), + "%M6440", + "%M06440", + "006440", + ), + ( + "%IX12345", + (AddressType.I, AddressLength.X, 12345, None), + "%IX12345", + "%IX12345", + "112345", + ), + ( + "%MX6440", + (AddressType.M, AddressLength.X, 6440, None), + "%MX6440", + "%MX06440", + "006440", + ), + ) + # Semi-good specs are valid IEC but not Modbus addresses. + self.semi_good_specs = ( + ("q03", (AddressType.Q, None, 3, None), "%Q3", "%Q00003"), + ( + "%QW7676.12", + (AddressType.Q, AddressLength.W, 7676, 12), + "%QW7676.12", + "%QW07676.12", + ), + ( + "%kd0", + (AddressType.K, AddressLength.D, 0, None), + "%KD0", + "%KD00000", + ), + ( + "%sw751", + (AddressType.S, AddressLength.W, 751, None), + "%SW751", + "%SW00751", + ), + ( + "%s323", + (AddressType.S, None, 323, None), + "%S323", + "%S00323", + ), + ) + self.bad_specs = ( + "goobledygook", + "%n300.4", + "40012.3", + "%M70000", + "%sw1000.17", + "%QF10", + ) + self.bad_args = (("n", None, 300, 4), ("Q", "F", 10, None)) + self.good_modbus = ( + ( + "400001", + 6, + False, + (AddressType.M, AddressLength.W, 1, None), + ), + ( + 400001, + 6, + False, + (AddressType.M, AddressLength.W, 1, None), + ), + ( + "400001", + 5, + False, + (AddressType.M, AddressLength.W, 1, None), + ), + ( + "40001", + 5, + False, + (AddressType.M, AddressLength.W, 1, None), + ), + ( + "40001", + 6, + False, + (AddressType.M, None, 40001, None), + ), + ( + "40001", + 6, + True, + (AddressType.M, AddressLength.X, 40001, None), + ), + ("000012", 6, False, (AddressType.M, None, 12, None)), + ("12", 6, False, (AddressType.M, None, 12, None)), + ("12", 6, True, (AddressType.M, AddressLength.X, 12, None)), + ("100000", 6, False, (AddressType.I, None, 0, None)), + ( + "100000", + 6, + True, + (AddressType.I, AddressLength.X, 0, None), + ), + ( + "300123", + 6, + False, + (AddressType.I, AddressLength.W, 123, None), + ), + ) + self.bad_modbus = ("200000", "goobledygook", 600000) + + def test_eq(self): + """Test that the __eq__ method returns False for non-Address `other`.""" + self.assertNotEqual( + Address(*self.good_specs[0][1]), IECType("test", IECClass.BINARY) + ) + + def test_init(self): + for args in self.bad_args: + with self.assertRaises(InvalidSpecError, msg=args): + Address(*args) + + def test_from_string(self): + for spec in self.good_specs + self.semi_good_specs: + self.assertEqual( + Address.from_string(spec[0]), Address(*spec[1]), spec[0] + ) + for spec in self.bad_specs: + with self.assertRaises(InvalidSpecError, msg=spec): + Address.from_string(spec) + + def test_from_modbus(self): + for spec in self.good_modbus: + self.assertEqual( + Address.from_modbus(spec[0], spec[1], spec[2]), + Address(*spec[3]), + ) + for spec in self.bad_modbus: + with self.assertRaises(InvalidSpecError, msg=spec): + Address.from_modbus(spec) + + def test_to_string(self): + for spec in self.good_specs: + self.assertEqual(str(Address(*spec[1])), spec[2], spec[0]) + self.assertEqual(Address(*spec[1]).to_string(5), spec[3], spec[0]) + + def test_to_modbus(self): + for spec in self.good_specs: + self.assertEqual(Address(*spec[1]).to_modbus(6), spec[4], spec[0]) + for spec in self.semi_good_specs: + with self.assertRaises(ValueError, msg=spec[0]): + Address(*spec[1]).to_modbus() + # Test whether to_modbus errors when the address is to large to fit in + # the specified number of digits. + self.assertRaises( + ValueError, Address(*self.good_specs[2][1]).to_modbus, 5 + ) + + class TestIECType(unittest.TestCase): def test_set_length(self): test_type = IECType( @@ -125,7 +317,8 @@ class TestArray(unittest.TestCase): spec[1], ) for spec in self.error_array_specs: - self.assertRaises(InvalidSpecError, Array, spec) + with self.assertRaises(InvalidSpecError, msg=spec): + Array(spec) def test_get_length(self): """Test get_length for both good and warning array specs.""" @@ -143,12 +336,12 @@ class TestArray(unittest.TestCase): warnings.simplefilter("ignore") for spec in self.good_array_specs + self.warning_array_specs: array = Array(spec[0]) - definition = array.make_definition("test_name", "test_comment") - definition.to_csv( - resources.files(output).joinpath( - f"array_definition_{str.strip(spec[0])}.csv" - ) - ) + definition = array.make_definition("test_name", "test_comment") # noqa: F841 + # definition.to_csv( + # resources.files(output).joinpath( + # f"array_definition_{str.strip(spec[0])}.csv" + # ) + # ) class TestString(unittest.TestCase): @@ -182,7 +375,8 @@ class TestString(unittest.TestCase): RuntimeWarning, String(spec[0], spec[2]).get_length, spec[1] ) for spec in error_string_specs: - self.assertRaises(InvalidSpecError, String, spec[0]) + with self.assertRaises(InvalidSpecError, msg=spec[0]): + String(spec[0]) if __name__ == "__main__":