opensignalbox-interface 0.1.0__py3-none-any.whl

opensignalbox/interface/interfaces/basicio/handler.py

@@ -0,0 +1,1096 @@
+"""
+Handler for Basic IO interfaces.
+"""
+
+import logging
+from math import ceil
+from typing import Any, Dict, cast
+
+from anyio import sleep
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import StreamingResponse
+from opensignalbox.common.messaging import get_messager
+from opensignalbox.common.sv_wire import decode_sv_message
+from opensignalbox.interface.adapters.base import BaseAdapter
+from opensignalbox.interface.interfaces.base import InterfaceHandler
+from opensignalbox.interface.interfaces.basicio.connections import (
+    BasicIOConnection,
+    BasicIOModbusConnection,
+    BasicIOTestConnection,
+)
+from opensignalbox.interface.models import Interface
+from opensignalbox.interface.utils import swap_bytes
+
+from .models import (
+    BasicIOConnectionType,
+    BasicIOForceMessage,
+    BasicIOInterface,
+    BasicIOInterfaceCreate,
+    BasicIOInterfacePublic,
+    BasicIOInterfaceUpdate,
+    IfaceChanTuple,
+    InputChannel,
+    InputChannelCreate,
+    OutputChannel,
+    OutputChannelCreate,
+)
+
+logger = logging.getLogger(__name__)
+messager = get_messager()
+
+STATUS_UPDATE_PERIOD = 0.2  # seconds
+
+
+class BasicIOInterfaceHandler(InterfaceHandler):
+    """Handler for Basic IO interfaces."""
+
+    # Metadata for the API discovery
+    metadata = {
+        "supported_connection_types": [
+            "BasicIOModbusConnection",
+            "BasicIOTestConnection",
+        ],
+        "required_fields": ["system_name", "user_name", "interface_type"],
+        "optional_fields": [
+            "description",
+            "adapter_name",
+            "enabled",
+            "modbus_address",
+            "input_start_address",
+            "output_start_address",
+            "input_bits",
+            "output_bits",
+        ],
+    }
+
+    @classmethod
+    def get_router(cls) -> Any:
+        """Get API router for Basic IO interface endpoints.
+
+        Returns:
+            FastAPI router with Basic IO interface specific endpoints
+        """
+
+        router = APIRouter(tags=["interfaces/basicio"])
+
+        @router.get("/{system_name}")
+        async def get_interface(system_name: str):
+            """Get a BasicIO interface by system name."""
+            if not cls.interface_controller:
+                raise HTTPException(
+                    status_code=500, detail="Interface controller not initialized"
+                )
+
+            try:
+                interface = cls.interface_controller.get(system_name)
+                if interface.interface_type != "BasicIO":
+                    raise HTTPException(
+                        status_code=404,
+                        detail=f"BasicIO interface '{system_name}' not found",
+                    )
+                return BasicIOInterfacePublic(
+                    **interface.model_dump(),
+                    input_map=[
+                        InputChannelCreate(**input.model_dump(), channel=channel)
+                        for channel, input in interface.input_channels.items()
+                    ],
+                    output_map=[
+                        OutputChannelCreate(**output.model_dump(), channel=channel)
+                        for channel, output in interface.output_channels.items()
+                    ],
+                )
+            except KeyError as exc:
+                raise HTTPException(
+                    status_code=404, detail=f"Interface '{system_name}' not found"
+                ) from exc
+
+        @router.post("/")
+        async def create_interface(interface: BasicIOInterfaceCreate):
+            """Create a new Basic IO interface."""
+            if not cls.interface_controller:
+                raise HTTPException(
+                    status_code=500, detail="Interface controller not initialized"
+                )
+
+            if interface.interface_type != "BasicIO":
+                raise HTTPException(
+                    status_code=400, detail="Interface type must be BasicIO"
+                )
+
+            try:
+                interface_model = BasicIOInterface(**interface.model_dump())
+
+                # Add the interface
+                new_interface = cls.interface_controller.add(interface_model)
+                return new_interface
+            except FileExistsError as exc:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Interface '{interface.system_name}' already exists",
+                ) from exc
+            except TypeError as exc:
+                raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+        @router.patch("/{system_name}")
+        async def update_interface(
+            system_name: str, interface_update: BasicIOInterfaceUpdate
+        ):
+            """Update a Basic IO interface."""
+            if not cls.interface_controller:
+                raise HTTPException(
+                    status_code=500, detail="Interface controller not initialized"
+                )
+
+            try:
+                # Check that the interface exists and is Basic IO type
+                interface = cls.interface_controller.get(system_name)
+                if interface.interface_type != "BasicIO":
+                    raise HTTPException(
+                        status_code=404,
+                        detail=f"Basic IO interface '{system_name}' not found",
+                    )
+
+                # Extract update fields
+                fields = {
+                    k: v
+                    for k, v in interface_update.model_dump().items()
+                    if v is not None
+                }
+
+                # Update the interface
+                updated_interface = cls.interface_controller.update(system_name, fields)
+                return updated_interface
+            except KeyError as exc:
+                raise HTTPException(
+                    status_code=404, detail=f"Interface '{system_name}' not found"
+                ) from exc
+
+        @router.delete("/{system_name}")
+        async def delete_interface(system_name: str):
+            """Delete a Basic IO interface."""
+            if not cls.interface_controller:
+                raise HTTPException(
+                    status_code=500, detail="Interface controller not initialized"
+                )
+
+            try:
+                # Check that the interface exists and is Basic IO type
+                interface = cls.interface_controller.get(system_name)
+                if interface.interface_type != "BasicIO":
+                    raise HTTPException(
+                        status_code=404,
+                        detail=f"Basic IO interface '{system_name}' not found",
+                    )
+
+                cls.interface_controller.remove(system_name)
+                return {"status": "success"}
+            except KeyError as exc:
+                raise HTTPException(
+                    status_code=404, detail=f"Interface '{system_name}' not found"
+                ) from exc
+
+        @router.post("/{system_name}/connect")
+        async def connect_interface(system_name: str):
+            """Connect to a Basic IO interface."""
+            if not cls.interface_controller:
+                raise HTTPException(
+                    status_code=500, detail="Interface controller not initialized"
+                )
+
+            try:
+                interface = cls.interface_controller.get(system_name)
+                if interface.interface_type != "BasicIO":
+                    raise HTTPException(
+                        status_code=404,
+                        detail=f"Basic IO interface '{system_name}' not found",
+                    )
+
+                # Connect to the interface
+                success = cls.connect(interface)
+                if success:
+                    return {"status": "success"}
+                else:
+                    raise HTTPException(
+                        status_code=500,
+                        detail=f"Failed to connect to interface. Detail: {interface.error}",
+                    )
+            except KeyError as exc:
+                raise HTTPException(
+                    status_code=404, detail=f"Interface '{system_name}' not found"
+                ) from exc
+
+        @router.get("/{system_name}/channel-status")
+        async def status_stream(request: Request, system_name: str):
+            """Stream the channel status of a Basic IO interface."""
+            if not cls.interface_controller:
+                raise HTTPException(
+                    status_code=500, detail="Interface controller not initialized"
+                )
+
+            try:
+
+                async def status_generator():
+                    if not cls.interface_controller:
+                        raise HTTPException(
+                            status_code=500,
+                            detail="Interface controller not initialized",
+                        )
+                    interface = cls.interface_controller.get(system_name)
+                    if interface.interface_type != "BasicIO":
+                        raise HTTPException(
+                            status_code=404,
+                            detail=f"Basic IO interface '{system_name}' not found",
+                        )
+                    while True:
+                        if await request.is_disconnected():
+                            break
+                        # Use controller's get_status method
+                        yield f"data: {cls.get_channel_status(interface)}\n\n"
+                        await sleep(STATUS_UPDATE_PERIOD)
+
+                return StreamingResponse(
+                    status_generator(), media_type="text/event-stream"
+                )
+
+            except KeyError as exc:
+                raise HTTPException(
+                    status_code=404, detail=f"Interface '{system_name}' not found"
+                ) from exc
+
+        @router.put("/{system_name}/forcing")
+        async def set_forcing(system_name: str, force_message: BasicIOForceMessage):
+            """Set forcing for a channel in a Basic IO interface."""
+            if not cls.interface_controller:
+                raise HTTPException(
+                    status_code=500, detail="Interface controller not initialized"
+                )
+
+            try:
+                interface = cls.interface_controller.get(system_name)
+                if interface.interface_type != "BasicIO":
+                    raise HTTPException(
+                        status_code=404,
+                        detail=f"Basic IO interface '{system_name}' not found",
+                    )
+
+                cls.set_forcing(
+                    interface,
+                    force_message.channel,
+                    force_message.iotype,
+                    force_message.state,
+                )
+                return {"status": "success"}
+            except KeyError as exc:
+                raise HTTPException(
+                    status_code=404, detail=f"Interface '{system_name}' not found"
+                ) from exc
+
+        return router
+
+    @staticmethod
+    def add(interface: Interface) -> Interface:
+        """
+        Initialize a BasicIOInterface from an Interface.
+
+        Args:
+            interface: The interface to initialize. Must be a BasicIOInterface or
+                      convertible to a BasicIOInterface.
+
+        Returns:
+            The initialized BasicIOInterface.
+
+        Raises:
+            TypeError: If the interface cannot be converted to a BasicIOInterface.
+        """
+
+        basicio_interface = cast(BasicIOInterface, interface)
+
+        # Initialize channels
+        for input in basicio_interface.input_channels.values():
+            input.shared_variable = (
+                BasicIOInterfaceHandler.output_variables.new_from_logic(
+                    system_name=input.system_name,
+                    user_name=input.user_name,
+                    description=input.description,
+                    tags=input.tags,
+                    value=input.default_value,
+                )
+            )
+
+        # Create channels for all configured bits
+        for channel in range(1, basicio_interface.input_bits + 1):
+            if channel not in basicio_interface.input_channels:
+                basicio_interface.input_channels[channel] = InputChannel(
+                    system_name="",
+                    user_name="",
+                    description="",
+                    tags=[],
+                    default_value=False,
+                )
+
+        # Set up variable subscriptions
+        if BasicIOInterfaceHandler.input_variable_subs is not None:
+            for channel, output in basicio_interface.output_channels.items():
+                if output.shared_variable_name:
+                    if (
+                        output.shared_variable_name
+                        not in BasicIOInterfaceHandler.input_variable_subs
+                    ):
+                        BasicIOInterfaceHandler.input_variable_subs[
+                            output.shared_variable_name
+                        ] = []
+                    BasicIOInterfaceHandler.input_variable_subs[
+                        output.shared_variable_name
+                    ].append(IfaceChanTuple(basicio_interface.system_name, channel))
+
+                    # Create a closure that captures the interface reference
+                    def create_variable_callback(iface):
+                        def callback(var: str, json_data: str):
+                            # Forward to controller's callback which has access to all interfaces
+                            if BasicIOInterfaceHandler.variable_update_callback:
+                                BasicIOInterfaceHandler.variable_update_callback(
+                                    var, json_data
+                                )
+
+                        return callback
+
+                    # Subscribe with the closure
+                    messager.sub(
+                        output.shared_variable_name,
+                        create_variable_callback(basicio_interface),
+                    )
+
+        # Ensure all output channels exist
+        for channel in range(1, basicio_interface.output_bits + 1):
+            if channel not in basicio_interface.output_channels:
+                basicio_interface.output_channels[channel] = OutputChannel(
+                    shared_variable_name=None
+                )
+
+        return basicio_interface
+
+    @staticmethod
+    def update(interface: Interface, fields: Dict[str, Any]) -> None:
+        """
+        Update a BasicIOInterface.
+
+        Args:
+            interface: The interface to update. Must be a BasicIOInterface or convertible to one.
+            fields: The fields to update.
+
+        Raises:
+            TypeError: If the interface cannot be converted to a BasicIOInterface.
+        """
+
+        basicio_interface = cast(BasicIOInterface, interface)
+
+        # Handle basic field updates
+        for field, value in fields.items():
+            if hasattr(basicio_interface, field) and value is not None:
+                setattr(basicio_interface, field, value)
+
+        # Clear input channels above input_bits limit
+        if "input_bits" in fields:
+            input_bits = fields["input_bits"]
+            channels_to_remove = [
+                ch for ch in basicio_interface.input_channels.keys() if ch > input_bits
+            ]
+            for channel_index in channels_to_remove:
+                # Clean up shared variable
+                channel = basicio_interface.input_channels[channel_index]
+                if channel.shared_variable:
+                    BasicIOInterfaceHandler.output_variables.remove(
+                        channel.shared_variable.system_name
+                    )
+                del basicio_interface.input_channels[channel_index]
+
+        # Clear output channels above output_bits limit
+        if "output_bits" in fields:
+            output_bits = fields["output_bits"]
+            channels_to_remove = [
+                ch
+                for ch in basicio_interface.output_channels.keys()
+                if ch > output_bits
+            ]
+            for channel_index in channels_to_remove:
+                # Clean up variable subscription
+                if basicio_interface.output_channels[
+                    channel_index
+                ].shared_variable_name:
+                    old_variable_name = basicio_interface.output_channels[
+                        channel_index
+                    ].shared_variable_name
+                    if old_variable_name in BasicIOInterfaceHandler.input_variable_subs:
+                        BasicIOInterfaceHandler.input_variable_subs[
+                            old_variable_name
+                        ] = [
+                            item
+                            for item in BasicIOInterfaceHandler.input_variable_subs[
+                                old_variable_name
+                            ]
+                            if not (
+                                item.interface == basicio_interface.system_name
+                                and item.channel == channel_index
+                            )
+                        ]
+                        # Clean up empty lists
+                        if not BasicIOInterfaceHandler.input_variable_subs[
+                            old_variable_name
+                        ]:
+                            del BasicIOInterfaceHandler.input_variable_subs[
+                                old_variable_name
+                            ]
+                del basicio_interface.output_channels[channel_index]
+
+        # Handle input channel updates (if provided)
+        input_map = fields.get("input_map")
+        if input_map is not None:
+            # Get list of channels in the new map
+            new_channels = {
+                channel_data.get("channel")
+                for channel_data in input_map
+                if channel_data.get("channel") is not None
+            }
+
+            # Remove channels not in the new map
+            channels_to_remove = [
+                ch
+                for ch in basicio_interface.input_channels.keys()
+                if ch not in new_channels
+            ]
+            logger.debug(
+                f"Removing channels: {channels_to_remove} from input channels of {basicio_interface.system_name}"
+            )
+            for channel_index in channels_to_remove:
+                # Clean up shared variable
+                channel = basicio_interface.input_channels[channel_index]
+                if channel.shared_variable:
+                    BasicIOInterfaceHandler.output_variables.remove(
+                        channel.shared_variable.system_name
+                    )
+                del basicio_interface.input_channels[channel_index]
+
+            # Process each channel in the input map
+            for channel_data in input_map:
+                channel_index = channel_data.get("channel")
+                if channel_index is None:
+                    continue
+
+                # Update or create channel
+                if channel_index in basicio_interface.input_channels:
+                    # Update existing channel
+                    for field, value in channel_data.items():
+                        if field != "channel" and hasattr(
+                            basicio_interface.input_channels[channel_index], field
+                        ):
+                            setattr(
+                                basicio_interface.input_channels[channel_index],
+                                field,
+                                value,
+                            )
+                else:
+                    # Create new channel
+                    basicio_interface.input_channels[channel_index] = InputChannel(
+                        system_name=channel_data.get("system_name", ""),
+                        user_name=channel_data.get("user_name", ""),
+                        description=channel_data.get("description", ""),
+                        tags=channel_data.get("tags", []),
+                        default_value=channel_data.get("default_value", False),
+                    )
+
+                    # Register shared variable if needed
+                    basicio_interface.input_channels[
+                        channel_index
+                    ].shared_variable = (
+                        BasicIOInterfaceHandler.output_variables.new_from_logic(
+                            system_name=basicio_interface.input_channels[
+                                channel_index
+                            ].system_name,
+                            user_name=basicio_interface.input_channels[
+                                channel_index
+                            ].user_name,
+                            description=basicio_interface.input_channels[
+                                channel_index
+                            ].description,
+                            tags=basicio_interface.input_channels[channel_index].tags,
+                            value=basicio_interface.input_channels[
+                                channel_index
+                            ].default_value,
+                        )
+                    )
+
+        # Handle output channel updates (if provided)
+        output_map = fields.get("output_map")
+        if output_map is not None:
+            # Get list of channels in the new map
+            new_channels = {
+                channel_data.get("channel")
+                for channel_data in output_map
+                if channel_data.get("channel") is not None
+            }
+
+            # Remove channels not in the new map
+            channels_to_remove = [
+                ch
+                for ch in basicio_interface.output_channels.keys()
+                if ch not in new_channels
+            ]
+            for channel_index in channels_to_remove:
+                # Clean up variable subscription
+                if basicio_interface.output_channels[
+                    channel_index
+                ].shared_variable_name:
+                    old_variable_name = basicio_interface.output_channels[
+                        channel_index
+                    ].shared_variable_name
+                    if old_variable_name in BasicIOInterfaceHandler.input_variable_subs:
+                        BasicIOInterfaceHandler.input_variable_subs[
+                            old_variable_name
+                        ] = [
+                            item
+                            for item in BasicIOInterfaceHandler.input_variable_subs[
+                                old_variable_name
+                            ]
+                            if not (
+                                item.interface == basicio_interface.system_name
+                                and item.channel == channel_index
+                            )
+                        ]
+                        # Clean up empty lists
+                        if not BasicIOInterfaceHandler.input_variable_subs[
+                            old_variable_name
+                        ]:
+                            del BasicIOInterfaceHandler.input_variable_subs[
+                                old_variable_name
+                            ]
+                del basicio_interface.output_channels[channel_index]
+
+            # Process each channel in the output map
+            for channel_data in output_map:
+                channel_index = channel_data.get("channel")
+                if channel_index is None:
+                    continue
+
+                # Check if we're changing the variable subscription
+                old_variable_name = None
+                if channel_index in basicio_interface.output_channels:
+                    old_variable_name = basicio_interface.output_channels[
+                        channel_index
+                    ].shared_variable_name
+
+                new_variable_name = channel_data.get("shared_variable_name")
+
+                # Update or create channel
+                if channel_index in basicio_interface.output_channels:
+                    # Update existing channel
+                    for field, value in channel_data.items():
+                        if field != "channel" and hasattr(
+                            basicio_interface.output_channels[channel_index], field
+                        ):
+                            setattr(
+                                basicio_interface.output_channels[channel_index],
+                                field,
+                                value,
+                            )
+                else:
+                    # Create new channel
+                    basicio_interface.output_channels[channel_index] = OutputChannel(
+                        shared_variable_name=channel_data.get("shared_variable_name")
+                    )
+
+                # Handle variable subscription changes if needed
+                if old_variable_name != new_variable_name:
+                    # Remove old subscription if it exists
+                    if (
+                        old_variable_name
+                        and old_variable_name
+                        in BasicIOInterfaceHandler.input_variable_subs
+                    ):
+                        BasicIOInterfaceHandler.input_variable_subs[
+                            old_variable_name
+                        ] = [
+                            item
+                            for item in BasicIOInterfaceHandler.input_variable_subs[
+                                old_variable_name
+                            ]
+                            if not (
+                                item.interface == basicio_interface.system_name
+                                and item.channel == channel_index
+                            )
+                        ]
+                        # Clean up empty lists
+                        if not BasicIOInterfaceHandler.input_variable_subs[
+                            old_variable_name
+                        ]:
+                            del BasicIOInterfaceHandler.input_variable_subs[
+                                old_variable_name
+                            ]
+                            # Unsubscribe
+                            BasicIOInterfaceHandler.input_variable_subs.pop(
+                                old_variable_name
+                            )
+
+                    # Add new subscription if needed
+                    if new_variable_name:
+                        if (
+                            new_variable_name
+                            not in BasicIOInterfaceHandler.input_variable_subs
+                        ):
+                            BasicIOInterfaceHandler.input_variable_subs[
+                                new_variable_name
+                            ] = []
+                        BasicIOInterfaceHandler.input_variable_subs[
+                            new_variable_name
+                        ].append(
+                            IfaceChanTuple(basicio_interface.system_name, channel_index)
+                        )
+
+                        # Create subscription
+                        def create_variable_callback(iface):
+                            def callback(var: str, json_data: str):
+                                # Forward to controller's callback which has access to all interfaces
+                                if BasicIOInterfaceHandler.variable_update_callback:
+                                    BasicIOInterfaceHandler.variable_update_callback(
+                                        var, json_data
+                                    )
+
+                            return callback
+
+                        # Subscribe with the closure
+                        messager.sub(
+                            new_variable_name,
+                            create_variable_callback(basicio_interface),
+                        )
+
+    @staticmethod
+    def remove(interface: Interface) -> None:
+        """
+        Remove a BasicIOInterface.
+
+        Args:
+            interface: The interface to remove.
+        """
+
+        basicio_interface = cast(BasicIOInterface, interface)
+
+        # Clean up variable subscriptions
+        for channel in basicio_interface.input_channels.values():
+            if channel.shared_variable:
+                BasicIOInterfaceHandler.output_variables.remove(
+                    channel.shared_variable.system_name
+                )
+        for variable, sub in BasicIOInterfaceHandler.input_variable_subs.items():
+            if sub[0] == basicio_interface.system_name:
+                BasicIOInterfaceHandler.input_variable_subs.pop(variable)
+
+    @staticmethod
+    def handle_variable_update(
+        interface: Interface, variable: str, json_data: str
+    ) -> None:
+        """
+        Handle a variable update for a BasicIOInterface.
+
+        Args:
+            interface: The interface to handle the update for.
+            variable: The name of the variable that was updated.
+            json_data: The JSON data of the updated variable.
+        """
+
+        basicio_interface = cast(BasicIOInterface, interface)
+
+        # Find channels subscribed to this variable
+        channels = []
+        if variable in BasicIOInterfaceHandler.input_variable_subs:
+            for item in BasicIOInterfaceHandler.input_variable_subs[variable]:
+                if item.interface == basicio_interface.system_name:
+                    channels.append(item.channel)
+
+        # No channels to update
+        if not channels:
+            return
+
+        # Parse the variable data
+        try:
+            data = decode_sv_message(json_data).data
+            value = bool(data.get("value", False))
+
+            # Update each channel
+            for channel in channels:
+                if channel in basicio_interface.output_channels:
+                    basicio_interface.output_channels[channel].variable_value = value
+        except Exception as e:
+            logger.error(f"Error parsing variable data: {e}")
+
+    @staticmethod
+    def connect(interface: Interface) -> bool:
+        """
+        Connect to a BasicIOInterface using the specified adapter.
+
+        Args:
+            interface: The interface to connect.
+            adapter: The adapter to use for communication.
+
+        Returns:
+            True if connection was successful, False otherwise.
+        """
+
+        basicio_interface = cast(BasicIOInterface, interface)
+
+        # Check if the interface is enabled
+        if not basicio_interface.enabled:
+            return False
+
+        # Get the appropriate connection strategy based on connection type
+        match basicio_interface.connection_type:
+            case BasicIOConnectionType.TEST:
+                return BasicIOTestConnection.connect(basicio_interface)
+            case (
+                BasicIOConnectionType.MODBUS_ADAPTER
+                | BasicIOConnectionType.DINGTIAN_MODBUS_ADAPTER
+            ):
+                if BasicIOInterfaceHandler.interface_controller:
+                    adapter = BasicIOInterfaceHandler.interface_controller.get_adapter_for_interface(
+                        interface
+                    )
+                    if not adapter or not adapter.enabled:
+                        return False  # No adapter configured or adapter is disabled
+                    return BasicIOModbusConnection.connect(basicio_interface, adapter)
+                return False  # No interface controller
+            case _:
+                logger.error(
+                    f"Unsupported connection type: {basicio_interface.connection_type}"
+                )
+                interface.error = (
+                    f"Unsupported connection type: {basicio_interface.connection_type}"
+                )
+                interface.enabled = False
+                return False
+
+    @staticmethod
+    def disconnect(interface: Interface) -> None:
+        """
+        Disconnect from a BasicIOInterface.
+
+        Args:
+            interface: The interface to disconnect.
+
+        Returns:
+            True if disconnection was successful, False otherwise.
+        """
+
+        basicio_interface = cast(BasicIOInterface, interface)
+
+        # Get the appropriate connection strategy based on connection type
+        match basicio_interface.connection_type:
+            case BasicIOConnectionType.TEST:
+                BasicIOTestConnection.disconnect(basicio_interface)
+            case (
+                BasicIOConnectionType.MODBUS_ADAPTER
+                | BasicIOConnectionType.DINGTIAN_MODBUS_ADAPTER
+            ):
+                if BasicIOInterfaceHandler.interface_controller:
+                    adapter = BasicIOInterfaceHandler.interface_controller.get_adapter_for_interface(
+                        interface
+                    )
+                    if not adapter:
+                        return
+                    BasicIOModbusConnection.disconnect(basicio_interface, adapter)
+            case _:
+                logger.error(
+                    f"Unsupported connection type: {basicio_interface.connection_type}"
+                )
+                interface.error = (
+                    f"Unsupported connection type: {basicio_interface.connection_type}"
+                )
+                interface.enabled = False
+                return
+
+    @staticmethod
+    def read_data(interface: Interface, adapter: BaseAdapter | None = None) -> None:
+        """
+        Read data from the adapter for a BasicIOInterface.
+
+        Args:
+            interface: The interface to read data for.
+            adapter: The adapter to read from.
+        """
+
+        basicio_interface = cast(BasicIOInterface, interface)
+
+        # Skip if no input bits
+        if basicio_interface.input_bits <= 0:
+            return
+
+        # Get the appropriate connection strategy based on connection type
+        connection: type[BasicIOConnection]
+        match basicio_interface.connection_type:
+            case BasicIOConnectionType.TEST:
+                connection = BasicIOTestConnection
+            case (
+                BasicIOConnectionType.MODBUS_ADAPTER
+                | BasicIOConnectionType.DINGTIAN_MODBUS_ADAPTER
+            ):
+                connection = BasicIOModbusConnection
+                if BasicIOInterfaceHandler.interface_controller:
+                    adapter = BasicIOInterfaceHandler.interface_controller.get_adapter_for_interface(
+                        interface
+                    )
+            case _:
+                logger.error(
+                    f"Unsupported connection type: {basicio_interface.connection_type}"
+                )
+                interface.error = (
+                    f"Unsupported connection type: {basicio_interface.connection_type}"
+                )
+                interface.enabled = False
+                return
+
+        # Read from the hardware
+        try:
+            # Read the words from the adapter (starting at the configured address)
+            data = connection.receive_data(basicio_interface, adapter=adapter)
+
+            if not data:
+                logger.error(
+                    f"No data read from adapter for interface '{basicio_interface.system_name}'"
+                )
+                return
+
+            # Convert data to integer array
+            words = []
+            for i in range(0, len(data), 2):
+                if i + 1 < len(data):
+                    word = (data[i] << 8) | data[i + 1]
+                    words.append(word)
+
+            # Apply byte and word swapping if needed
+            if basicio_interface.input_byte_swap:
+                words = [swap_bytes(word) for word in words]
+
+            if basicio_interface.input_word_swap and len(words) >= 2:
+                for i in range(0, len(words), 2):
+                    if i + 1 < len(words):
+                        words[i], words[i + 1] = words[i + 1], words[i]
+
+            # Update channel values
+            for channel_index in range(1, basicio_interface.input_bits + 1):
+                if channel_index in basicio_interface.input_channels:
+                    # Calculate word index and bit position
+                    word_idx = (channel_index - 1) // 16
+                    bit_pos = (channel_index - 1) % 16
+
+                    # Get the bit value if the word index is valid
+                    if word_idx < len(words):
+                        bit_value = bool((words[word_idx] >> bit_pos) & 1)
+
+                        channel = basicio_interface.input_channels[channel_index]
+
+                        # Update the hardware value
+                        channel.hardware_value = bit_value
+
+                        channel.variable_value = (
+                            channel.force_value if channel.force_enable else bit_value
+                        )
+
+                        # Update the shared variable if changed
+                        if channel.shared_variable is not None:
+                            if (
+                                channel.shared_variable.data.model_dump()["value"]
+                                != channel.variable_value
+                            ):
+                                channel.shared_variable.update(
+                                    {"value": channel.variable_value}
+                                )
+        except Exception as e:
+            logger.error(
+                f"Error reading data for interface '{basicio_interface.system_name}': {e}"
+            )
+            interface.error = str(e)
+
+    @staticmethod
+    def write_data(interface: Interface, adapter: BaseAdapter | None = None) -> None:
+        """
+        Write data to the adapter for a BasicIOInterface.
+
+        Args:
+            interface: The interface to write data for.
+            adapter: The adapter to write to.
+        """
+
+        basicio_interface = cast(BasicIOInterface, interface)
+
+        # Skip if no output bits
+        if basicio_interface.output_bits <= 0:
+            return
+
+        # Calculate number of words needed to represent all bits
+        num_words = ceil(basicio_interface.output_bits / 16)
+
+        # Prepare words array
+        words = [0] * num_words
+
+        # Set bits based on channel values
+        for channel in range(1, basicio_interface.output_bits + 1):
+            if channel in basicio_interface.output_channels:
+                # Calculate word index and bit position
+                word_idx = (channel - 1) // 16
+                bit_pos = (channel - 1) % 16
+
+                # Determine the value to write
+                if basicio_interface.output_channels[channel].force_enable:
+                    # Use forced value if forcing is enabled
+                    value = basicio_interface.output_channels[channel].force_value
+                else:
+                    # Otherwise use the variable value
+                    value = basicio_interface.output_channels[channel].variable_value
+
+                # Set the bit in the corresponding word
+                if value:
+                    words[word_idx] |= 1 << bit_pos
+
+        # Apply byte and word swapping if needed
+        if basicio_interface.output_byte_swap:
+            words = [swap_bytes(word) for word in words]
+
+        if basicio_interface.output_word_swap and len(words) >= 2:
+            for i in range(0, len(words), 2):
+                if i + 1 < len(words):
+                    words[i], words[i + 1] = words[i + 1], words[i]
+
+        # Convert words to byte array
+        data = bytearray()
+        for word in words:
+            data.append(word & 0xFF)  # Low byte
+            data.append((word >> 8) & 0xFF)  # High byte
+
+        connection: type[BasicIOConnection]
+        # Get the appropriate connection strategy based on connection type
+        match basicio_interface.connection_type:
+            case BasicIOConnectionType.TEST:
+                connection = BasicIOTestConnection
+            case (
+                BasicIOConnectionType.MODBUS_ADAPTER
+                | BasicIOConnectionType.DINGTIAN_MODBUS_ADAPTER
+            ):
+                connection = BasicIOModbusConnection
+                if BasicIOInterfaceHandler.interface_controller:
+                    adapter = BasicIOInterfaceHandler.interface_controller.get_adapter_for_interface(
+                        interface
+                    )
+            case _:
+                logger.error(
+                    f"Unsupported connection type: {basicio_interface.connection_type}"
+                )
+                interface.error = (
+                    f"Unsupported connection type: {basicio_interface.connection_type}"
+                )
+                interface.enabled = False
+                return
+
+        # Write to the adapter
+        try:
+            connection.send_data(basicio_interface, data=data, adapter=adapter)
+            # Update hardware value after successful write
+            for channel in range(1, basicio_interface.output_bits + 1):
+                if channel in basicio_interface.output_channels:
+                    if basicio_interface.output_channels[channel].force_enable:
+                        basicio_interface.output_channels[
+                            channel
+                        ].hardware_value = basicio_interface.output_channels[
+                            channel
+                        ].force_value
+                    else:
+                        basicio_interface.output_channels[
+                            channel
+                        ].hardware_value = basicio_interface.output_channels[
+                            channel
+                        ].variable_value
+        except Exception as e:
+            logger.error(
+                f"Error writing data for interface '{basicio_interface.system_name}': {e}"
+            )
+            interface.error = str(e)
+
+    @staticmethod
+    def get_channel_status(interface: Interface):
+        """
+        Get the channel status of a BasicIOInterface.
+
+        Args:
+            interface: The interface to get the status of.
+
+        Returns:
+            A string describing the current status.
+        """
+
+        basicio_interface = cast(BasicIOInterface, interface)
+
+        return basicio_interface.model_dump_json(
+            include={"input_channels", "output_channels"}, by_alias=True
+        )
+
+    @staticmethod
+    def set_forcing(
+        interface: Interface, channel_index: int, iotype: str, state: str
+    ) -> None:
+        """
+        Set forcing for a channel in a BasicIOInterface.
+
+        Args:
+            interface: The interface to set forcing for.
+            channel: The channel number.
+            is_input: Whether the channel is an input.
+            enabled: Whether forcing is enabled.
+            value: The value to force.
+        """
+
+        if iotype not in ["input", "output"]:
+            raise ValueError("Invalid iotype. Must be 'input' or 'output'.")
+        if state not in ["on", "off", "none"]:
+            raise ValueError("Invalid state. Must be 'on', 'off', or 'none'.")
+        if channel_index is None:
+            raise ValueError("Channel must be specified.")
+
+        basicio_interface = cast(BasicIOInterface, interface)
+
+        # Set forcing for the specified channel
+        if iotype == "input":
+            if channel_index in basicio_interface.input_channels:
+                channel = basicio_interface.input_channels[channel_index]
+                channel.force_enable = state in ["on", "off"]
+                channel.force_value = state == "on"
+
+                # Update shared variable if forced
+                if channel.force_enable:
+                    channel.variable_value = channel.force_value
+                else:
+                    # If not forcing, reset the variable value to hardware value
+                    channel.variable_value = channel.hardware_value
+
+                if channel.shared_variable is not None:
+                    # Update the shared variable value if changed
+                    if (
+                        channel.shared_variable.data.model_dump()["value"]
+                        != channel.variable_value
+                    ):
+                        channel.shared_variable.update(
+                            {"value": channel.variable_value}
+                        )
+        else:
+            if channel_index in basicio_interface.output_channels:
+                channel = basicio_interface.output_channels[channel_index]
+                channel.force_enable = state in ["on", "off"]
+                channel.force_value = state == "on"
+
+    @classmethod
+    def load_from_json(cls, interface_data: Any) -> None:
+        basicio_interface = BasicIOInterface.model_validate(interface_data)
+        if cls.interface_controller is None:
+            raise ValueError(
+                "Interface controller not set. Call set_controller() first."
+            )
+        cls.interface_controller.add(basicio_interface)
+
+    @staticmethod
+    def save_to_json(interface: Interface) -> str:
+        return interface.model_dump_json()