opensignalbox-interface 0.1.0__py3-none-any.whl

opensignalbox/interface/interfaces/basicio/models.py

@@ -0,0 +1,165 @@
+"""
+Basic IO interface models.
+"""
+
+from collections import namedtuple
+from enum import Enum
+from typing import Dict, List, Literal, Optional
+
+from opensignalbox.common.models import CamelModel
+from opensignalbox.common.variables import SharedVariable
+from opensignalbox.interface.models import (
+    Interface,
+    InterfaceBase,
+    InterfaceTypeEnum,
+    InterfaceUpdate,
+)
+
+__MAX_CHANNEL_COUNT__ = 128
+
+
+class BasicIOConnectionType(str, Enum):
+    """Connection types for BasicIO interfaces."""
+
+    MODBUS_ADAPTER = "ModbusAdapter"
+    DINGTIAN_MODBUS_ADAPTER = "DingtianModbusAdapter"  # Used at Lowdham
+    DIRECT_TCP = "DirectTCP"
+    TEST = "Test"  # For testing purposes only
+
+
+class ForceChannelTypeEnum(str, Enum):
+    """Enum for force channel types."""
+
+    INPUT = "input"
+    OUTPUT = "output"
+
+
+class ForceStateEnum(str, Enum):
+    """Enum for force states."""
+
+    ON = "on"
+    OFF = "off"
+    NONE = "none"  # To remove forcing
+
+
+# Tuple for pairing interface name with channel number
+IfaceChanTuple = namedtuple("IfaceChanTuple", ["interface", "channel"])
+
+
+class InputChannelBase(CamelModel):
+    """Base model for input channels."""
+
+    system_name: str
+    user_name: str
+    description: str
+    tags: List[str]
+    default_value: bool
+
+
+class InputChannelCreate(InputChannelBase):
+    """API model for creating input channels."""
+
+    channel: int
+
+
+class OutputChannelBase(CamelModel):
+    """Base model for output channels."""
+
+    shared_variable_name: Optional[str] = None
+
+
+class OutputChannelCreate(OutputChannelBase):
+    """API model for creating output channels."""
+
+    channel: int
+
+
+class InputChannel(InputChannelBase):
+    """Runtime model for input channels."""
+
+    hardware_value: bool = False
+    force_enable: bool = False
+    force_value: bool = False
+    variable_value: bool = False
+    shared_variable: Optional[SharedVariable] = None
+
+
+class OutputChannel(OutputChannelBase):
+    """Runtime model for output channels."""
+
+    variable_value: bool = False
+    force_enable: bool = False
+    force_value: bool = False
+    hardware_value: bool = False
+
+
+class BasicIOInterfaceFields(CamelModel):
+    """Mixin with BasicIO-specific fields."""
+
+    connection_type: BasicIOConnectionType = BasicIOConnectionType.MODBUS_ADAPTER
+    input_start_address: int = 0
+    input_bits: int = 0
+    input_byte_swap: bool = False
+    input_word_swap: bool = False
+    output_start_address: int = 0
+    output_bits: int = 0
+    output_byte_swap: bool = False
+    output_word_swap: bool = False
+
+    # Fields for modbus connection
+    modbus_address: Optional[int] = None
+
+    # Fields for TCP connection
+    tcp_host: Optional[str] = None
+    tcp_port: Optional[int] = None
+
+
+class BasicIOInterfaceBase(Interface, BasicIOInterfaceFields):
+    """Base model with BasicIO-specific fields."""
+
+    pass
+
+
+class BasicIOInterface(BasicIOInterfaceBase):
+    """Runtime model for BasicIO interfaces."""
+
+    input_channels: Dict[int, InputChannel] = {}
+    output_channels: Dict[int, OutputChannel] = {}
+
+
+class BasicIOInterfaceCreate(InterfaceBase, BasicIOInterfaceFields):
+    """API model for creating BasicIO interfaces."""
+
+    interface_type: Literal[InterfaceTypeEnum.BASICIO] = InterfaceTypeEnum.BASICIO
+    input_map: List[InputChannelCreate] = []
+    output_map: List[OutputChannelCreate] = []
+
+
+class BasicIOInterfacePublic(BasicIOInterfaceBase):
+    """API model for BasicIO interface responses."""
+
+    input_map: List[InputChannelCreate] = []
+    output_map: List[OutputChannelCreate] = []
+
+
+class BasicIOInterfaceUpdate(InterfaceUpdate):
+    """API model for updating BasicIO interfaces."""
+
+    input_start_address: Optional[int] = None
+    input_bits: Optional[int] = None
+    input_byte_swap: Optional[bool] = None
+    input_word_swap: Optional[bool] = None
+    output_start_address: Optional[int] = None
+    output_bits: Optional[int] = None
+    output_byte_swap: Optional[bool] = None
+    output_word_swap: Optional[bool] = None
+    input_map: Optional[List[InputChannelCreate]] = None
+    output_map: Optional[List[OutputChannelCreate]] = None
+
+
+class BasicIOForceMessage(CamelModel):
+    """Message for setting force state on BasicIO channels."""
+
+    iotype: ForceChannelTypeEnum
+    channel: int
+    state: ForceStateEnum

opensignalbox/interface/interfaces/bell/__init__.py

@@ -0,0 +1,3 @@
+"""
+Bell interface implementation.
+"""

opensignalbox/interface/interfaces/bell/connections.py

@@ -0,0 +1,279 @@
+import functools
+import logging
+import socket
+from abc import ABC, abstractmethod
+
+from opensignalbox.interface.adapters.base import BaseAdapter
+from opensignalbox.interface.interfaces.bell.models import BellInterface
+
+logger = logging.getLogger(__name__)
+
+
+def modbus_exception_handler(func):
+    @functools.wraps(func)
+    def wrapper(cls, interface, *args, **kwargs):
+        try:
+            return func(cls, interface, *args, **kwargs)
+        except (BrokenPipeError, ConnectionResetError, OSError, socket.error) as e:
+            logger.error(
+                f"Modbus TCP error for '{interface.system_name}' channel {kwargs.get('channel', 'n/a')}: {e}"
+            )
+            interface.error = f"TCP error: {e}"
+            BellModbusConnection.disconnect(interface, kwargs.get("adapter"))
+            BellModbusConnection.connect(interface, kwargs.get("adapter"))
+            return (
+                bytearray(b"")
+                if func.__name__.startswith("receive")
+                or func.__name__.startswith("get")
+                else None
+            )
+
+    return wrapper
+
+
+class BellConnection(ABC):
+    """Base abstract class for all bell connections."""
+
+    @classmethod
+    @abstractmethod
+    def connect(
+        cls, interface: BellInterface, adapter: BaseAdapter | None = None
+    ) -> bool:
+        """Connect to the bell interface."""
+        pass
+
+    @classmethod
+    @abstractmethod
+    def disconnect(
+        cls, interface: BellInterface, adapter: BaseAdapter | None = None
+    ) -> bool:
+        """Disconnect from the bell interface."""
+        pass
+
+    @classmethod
+    @abstractmethod
+    def send_code(
+        cls,
+        interface: BellInterface,
+        channel: int,
+        data: bytearray,
+        adapter: BaseAdapter | None = None,
+    ) -> None:
+        """Send data through the bell interface."""
+        pass
+
+    @classmethod
+    @abstractmethod
+    def receive_code(
+        cls, interface: BellInterface, channel: int, adapter: BaseAdapter | None = None
+    ) -> bytearray:
+        """Receive data from the bell interface."""
+        pass
+
+    @classmethod
+    @abstractmethod
+    def receive_all_codes(
+        cls, interface: BellInterface, adapter: BaseAdapter | None = None
+    ) -> bytearray:
+        """Receive data from the bell interface."""
+        pass
+
+
+class BellTestConnection(BellConnection):
+    """Test implementation of the BellConnection for unit testing."""
+
+    in_1_count: int = 1
+    out_1_count: int = 0
+    in_2_count: int = 1
+    out_2_count: int = 0
+    in_3_count: int = 1
+    out_3_count: int = 0
+    in_4_count: int = 1
+    out_4_count: int = 0
+
+    @classmethod
+    def connect(
+        cls, interface: BellInterface, adapter: BaseAdapter | None = None
+    ) -> bool:
+        """Simulate connecting to the interface."""
+        logger.debug(
+            f"Connecting to interface {interface.system_name} with test connection."
+        )
+        interface.is_connected = True
+        return True
+
+    @classmethod
+    def disconnect(
+        cls, interface: BellInterface, adapter: BaseAdapter | None = None
+    ) -> bool:
+        """Simulate disconnecting from the interface."""
+        logger.debug(
+            f"Disconnecting from interface {interface.system_name} with test connection."
+        )
+        interface.is_connected = False
+        return True
+
+    @classmethod
+    def send_code(
+        cls,
+        interface: BellInterface,
+        channel: int,
+        data: bytearray,
+        adapter: BaseAdapter | None = None,
+    ) -> None:
+        """Simulate sending data."""
+        # logger.debug(f"Sending data to interface {interface.system_name} on channel {channel} with test connection. Data: {data.hex()}")
+        return
+
+    @classmethod
+    def receive_code(
+        cls, interface: BellInterface, channel: int, adapter: BaseAdapter | None = None
+    ) -> bytearray:
+        """Simulate receiving data."""
+        response = bytearray()
+        count = interface.channels[channel].out_count
+        code = interface.channels[channel].out_code
+
+        response.append((count >> 8) & 0xFF)
+        response.append(count & 0xFF)
+
+        for i in range(1, 8):
+            if i - 1 < len(code.split(",")):
+                try:
+                    response += (int(code.split(",")[i - 1])).to_bytes(2)
+                except ValueError:
+                    response += (0).to_bytes(2)
+            else:
+                response += (0).to_bytes(2)
+
+        # logger.debug(f"Receiving data from interface {interface.system_name} on channel {channel} with test connection. Data: {response.hex()}")
+        # Simulate receiving data
+        return response
+
+    @classmethod
+    def receive_all_codes(
+        cls, interface: BellInterface, adapter: BaseAdapter | None = None
+    ) -> bytearray:
+        """Simulate receiving data."""
+        response = bytearray()
+        return response
+
+
+class BellModbusConnection(BellConnection):
+    """Modbus implementation of the BellConnection."""
+
+    in_start_addresses = {
+        1: 41000,
+        2: 42000,
+        3: 43000,
+        4: 44000,
+    }
+
+    in_fast_start_address = 45000
+
+    out_start_addresses = {
+        1: 41100,
+        2: 42100,
+        3: 43100,
+        4: 44100,
+    }
+
+    code_length: int = 8
+
+    @classmethod
+    def connect(
+        cls, interface: BellInterface, adapter: BaseAdapter | None = None
+    ) -> bool:
+        """Connect to the Modbus interface."""
+        logger.debug(f"Connecting to Bell Modbus interface {interface.system_name}.")
+        if adapter is not None:
+            if not adapter.is_connected:
+                adapter.connect()
+                if adapter.is_connected:
+                    interface.is_connected = True
+                    return True
+            else:
+                interface.is_connected = True
+                return True
+        return False
+
+    @classmethod
+    def disconnect(
+        cls, interface: BellInterface, adapter: BaseAdapter | None = None
+    ) -> bool:
+        """Disconnect from the Modbus interface."""
+        logger.debug(
+            f"Disconnecting from Bell Modbus interface {interface.system_name}."
+        )
+        interface.is_connected = False
+        return True
+
+    @classmethod
+    @modbus_exception_handler
+    def send_code(
+        cls,
+        interface: BellInterface,
+        channel: int,
+        data: bytearray,
+        adapter: BaseAdapter | None = None,
+    ) -> None:
+        """Send data through the Modbus interface."""
+        if adapter is not None and interface.modbus_address is not None:
+            command = 16
+            cmd = interface.modbus_address.to_bytes()
+            cmd += command.to_bytes()
+            cmd += cls.out_start_addresses[channel].to_bytes(2)
+            cmd += cls.code_length.to_bytes(2)
+            cmd += len(data).to_bytes()
+            cmd += data
+            adapter.attempt_write(cmd)
+            adapter.attempt_read()
+        return
+
+    @classmethod
+    @modbus_exception_handler
+    def receive_code(
+        cls, interface: BellInterface, channel: int, adapter: BaseAdapter | None = None
+    ) -> bytearray:
+        """Receive data from the Modbus interface."""
+        if adapter is not None and interface.modbus_address is not None:
+            command = 3
+            cmd = interface.modbus_address.to_bytes()
+            cmd += command.to_bytes()
+            cmd += cls.in_start_addresses[channel].to_bytes(2)
+            cmd += cls.code_length.to_bytes(2)
+            adapter.attempt_write(cmd)
+            return adapter.attempt_read()
+        return bytearray(b"")
+
+    @classmethod
+    @modbus_exception_handler
+    def receive_all_codes(
+        cls, interface: BellInterface, adapter: BaseAdapter | None = None
+    ) -> bytearray:
+        """Receive data from the Modbus interface."""
+        if adapter is not None and interface.modbus_address is not None:
+            command = 3
+            cmd = interface.modbus_address.to_bytes()
+            cmd += command.to_bytes()
+            cmd += cls.in_fast_start_address.to_bytes(2)
+            cmd += (cls.code_length * 4 + 4).to_bytes(2)
+            adapter.attempt_write(cmd)
+            return adapter.attempt_read()
+        return bytearray(b"")
+
+    @classmethod
+    @modbus_exception_handler
+    def get_sent_code(
+        cls, interface: BellInterface, channel: int, adapter: BaseAdapter | None = None
+    ) -> bytearray:
+        """Get the last sent code for a channel."""
+        if adapter is not None and interface.modbus_address is not None:
+            command = 3
+            cmd = interface.modbus_address.to_bytes()
+            cmd += command.to_bytes()
+            cmd += cls.out_start_addresses[channel].to_bytes(2)
+            cmd += cls.code_length.to_bytes(2)
+            adapter.attempt_write(cmd)
+            return adapter.attempt_read()
+        return bytearray(b"")