syndesi 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

syndesi/protocols/modbus.py

@@ -1,22 +1,57 @@
 # File : modbus.py
 # Author : Sébastien Deriaz
 # License : GPL
+"""
+Modbus TCP and Modbus RTU implementation
+"""
+
+# PDU (Protocol Data Unit) format
+#
+# Modbus TCP
+# ┌────────────────┬─────────────┬────────┬─────────┬───────┐
+# │ Transaction ID │ Protocol ID │ Length │ Unit ID │ Data  │
+# └────────────────┴─────────────┴────────┴─────────┴───────┘
+#       2 bytes        2 bytes     2 bytes   1 byte  N bytes
+#
+#
+# Modbus RTU
+# ┌───────────────┬────────┬────────┐
+# │ Slave address │  Data  │  CRC   │
+# └───────────────┴────────┴────────┘
+#      1 byte       N bytes  2 bytes
 #
+# Modbus ASCII
+# ┌────────┬───────────────┬────────┬───────┬─────────┐
+# │ HEADER │ Slave address │  Data  │  CRC  │ TRAILER │
+# └────────┴───────────────┴────────┴───────┴─────────┘
+#   1 byte      1 byte       N bytes 2 bytes   1 byte
 #
-# Modbus TCP and Modbus RTU implementation
+#
+# The PDU is built and parsed by the Modbus class, each data block (SDU)
+# is constructed by its corresponding ModbusRequestSDU class. SDUs are parsed
+# by ModbusResponseSDU classes
+
+# pylint: disable=too-many-lines
+
+from __future__ import annotations
 
 import struct
+from abc import abstractmethod
+from dataclasses import dataclass
 from enum import Enum
 from math import ceil
+from types import EllipsisType
 from typing import cast
-from unittest.mock import DEFAULT
+
+from syndesi.adapters.adapter_worker import AdapterEvent
+from syndesi.component import AdapterFrame
 
 from ..adapters.adapter import Adapter
 from ..adapters.ip import IP
 from ..adapters.serialport import SerialPort
-from ..adapters.stop_condition import Continuation, Length
 from ..adapters.timeout import Timeout
-from .protocol import Protocol
+from ..tools.errors import ProtocolError, ProtocolReadError
+from .protocol import Protocol, ProtocolFrame
 
 MODBUS_TCP_DEFAULT_PORT = 502
 
@@ -29,13 +64,18 @@ MAX_DISCRETE_INPUTS = (
 # This value has been checked and going up to 1976 seems to work but sticking to the
 # spec is safer
 
-# Specification says 125, but write_multiple_registers would exceed the allow number of bytes in that case
+# Specification says 125, but write_multiple_registers would exceed the allow number
+# of bytes in that case
 # MAX_NUMBER_OF_REGISTERS = 123
 
 ExceptionCodesType = dict[int, str]
 
 
 class Endian(Enum):
+    """
+    Endian enum
+    """
+
     BIG = "big"
     LITTLE = "little"
 
@@ -43,6 +83,64 @@ class Endian(Enum):
 endian_symbol = {Endian.BIG: ">", Endian.LITTLE: "<"}
 
 
+def _dm_to_pdu_address(dm_address: int) -> int:
+    """
+    Convert Modbus data model address to Modbus PDU address
+
+    - Modbus data model starts at address 1
+    - Modbus PDU addresses start at 0
+
+    Modbus data model is the one specified in the devices datasheets
+
+    Parameters
+    ----------
+    dm_address : int
+    """
+    if dm_address == 0:
+        raise ValueError("Address 0 is not valid in Modbus data model")
+
+    return dm_address - 1
+
+
+def _pdu_to_dm_address(pdu_address: int) -> int:
+    """
+    Convert Modbus PDU address to Modbus data model address
+
+    - Modbus data model starts at address 1
+    - Modbus PDU addresses start at 0
+
+    Modbus data model is the one specified in the devices datasheets
+
+    Parameters
+    ----------
+    pdu_address : int
+    """
+    return pdu_address + 1
+
+
+def _check_discrete_input_output_count(discrete_inputs: int) -> None:
+    if not 1 <= discrete_inputs <= MAX_DISCRETE_INPUTS:
+        raise ValueError(
+            f"Invalid number of inputs/outputs : {discrete_inputs}, it must be in "
+            f"the range [1, {MAX_DISCRETE_INPUTS}]"
+        )
+
+
+def _check_address(address: int, max_address: int | None = None) -> None:
+    if not MIN_ADDRESS <= address <= MAX_ADDRESS:
+        raise ValueError(
+            f"Invalid address : {address}, it must be in the range "
+            f"[{MIN_ADDRESS},{MAX_ADDRESS}]"
+        )
+
+    if max_address is not None:
+        if address > max_address:
+            raise ValueError(
+                f"Invalid address : {address}, it cannot exceed {max_address}"
+                " in the current context"
+            )
+
+
 ENDIAN = endian_symbol[Endian.BIG]
 
 # TCP
@@ -54,14 +152,31 @@ ENDIAN = endian_symbol[Endian.BIG]
 # Size limitation only apply to Modbus RTU
 AVAILABLE_PDU_SIZE = 255 - 3
 
+_ASCII_HEADER = b":"
+_PROTOCO_ID = 0
+_UNIT_ID = 0
+_ASCII_TRAILER = b"\r\n"
+
 
 class ModbusType(Enum):
+    """
+    Modbus type
+
+    - TCP : Modbus over TCP
+    - RTU : Modbus over serial
+    - ASCII : Modbus using text based encoding
+    """
+
     RTU = "RTU"
     ASCII = "ASCII"
     TCP = "TCP"
 
 
 class FunctionCode(Enum):
+    """
+    Modbus function codes enum
+    """
+
     # Public function codes 1 to 64
     READ_COILS = 0x01
     READ_DISCRETE_INPUTS = 0x02
@@ -89,6 +204,10 @@ class FunctionCode(Enum):
 
 
 class DiagnosticsCode(Enum):
+    """
+    Modbus Diagnostics codes enum
+    """
+
     RETURN_QUERY_DATA = 0x00
     RESTART_COMMUNICATIONS_OPTION = 0x01
     RETURN_DIAGNOSTIC_REGISTER = 0x02
@@ -110,11 +229,19 @@ class DiagnosticsCode(Enum):
 
 
 class EncapsulatedInterfaceTransportSubFunctionCodes(Enum):
+    """
+    Encapsulated interface transport subfunction codes enum
+    """
+
     CANOPEN_GENERAL_REFERENCE_REQUEST_AND_RESPONSE_PDU = 0x0D
     READ_DEVICE_IDENTIFICATION = 0x0E
 
 
 class DeviceIndentificationObjects(Enum):
+    """
+    Device identification objects enum
+    """
+
     VENDOR_NAME = 0x00
     PRODUCT_CODE = 0x01
     MAJOR_MINOR_REVISION = 0x02
@@ -135,20 +262,28 @@ SERIAL_LINE_ONLY_CODES = [
 
 
 def bool_list_to_bytes(lst: list[bool]) -> bytes:
+    """
+    Convert a list of bool to bytes, LSB first
+    """
     byte_count = ceil(len(lst) / 8)
-    result: bytes = sum([2**i * int(v) for i, v in enumerate(lst)]).to_bytes(
+    result: bytes = sum(2**i * int(v) for i, v in enumerate(lst)).to_bytes(
         byte_count, byteorder="little"
     )
     return result
 
 
-def bytes_to_bool_list(_bytes: bytes, N: int) -> list[bool]:
-    return [
-        True if c == "1" else False for c in "".join([f"{x:08b}"[::-1] for x in _bytes])
-    ][:N]
+def bytes_to_bool_list(_bytes: bytes, n: int) -> list[bool]:
+    """
+    Convert bytes to a list of bool, one per bit, LSB first
+    """
+    return [c == "1" for c in "".join([f"{x:08b}"[::-1] for x in _bytes])][:n]
 
 
 class TypeCast(Enum):
+    """
+    Type of cast when storing values in modbus registers
+    """
+
     INT = "int"
     UINT = "uint"
     FLOAT = "float"
@@ -156,467 +291,1506 @@ class TypeCast(Enum):
     ARRAY = "array"
 
     def is_number(self) -> bool:
+        """
+        Return True if the type is a number
+        """
         return self in [TypeCast.INT, TypeCast.UINT, TypeCast.FLOAT]
 
 
-def struct_format(type: TypeCast, length: int) -> str:
-    if type == TypeCast.INT:
-        if length == 1:
-            return "b"
-        elif length == 2:
-            return "h"
-        elif length == 4:
-            return "i"  # or 'l'
-        elif length == 8:
-            return "q"
-    elif type == TypeCast.UINT:
-        if length == 1:
-            return "B"
-        elif length == 2:
-            return "H"
-        elif length == 4:
-            return "I"  # or 'L'
-        elif length == 8:
-            return "Q"
-    elif type == TypeCast.FLOAT:
-        if length == 4:
-            return "f"
-        elif length == 8:
-            return "d"
-    elif type == TypeCast.STRING or type == TypeCast.ARRAY:
+def struct_format(_type: TypeCast, length: int) -> str:
+    """
+    Convert typecast+length to python struct character
+    """
+    struct_characters = {
+        (TypeCast.INT, 1): "b",
+        (TypeCast.INT, 2): "h",
+        (TypeCast.INT, 4): "i",
+        (TypeCast.INT, 8): "q",
+        (TypeCast.UINT, 1): "B",
+        (TypeCast.UINT, 2): "H",
+        (TypeCast.UINT, 4): "I",  # or 'L'
+        (TypeCast.UINT, 8): "Q",
+        (TypeCast.FLOAT, 4): "f",
+        (TypeCast.FLOAT, 8): "d",
+    }
+
+    if _type in [TypeCast.STRING, TypeCast.ARRAY]:
         return f"{length}s"
-    else:
-        raise ValueError(f"Unknown cast type : {type}")
-    raise ValueError(f"Invalid type cast / length combination : {type} / {length}")
-
+    try:
+        return struct_characters[_type, length]
+    except KeyError:
+        pass
+    raise ValueError(f"Invalid type cast / length combination : {_type} / {length}")
 
-class ModbusException(Exception):
-    pass
 
+class ModbusError(Exception):
+    """
+    Generic modbus exception
+    """
 
-class Modbus(Protocol):
-    _ASCII_HEADER = b":"
-    _ASCII_TRAILER = b"\r\n"
 
-    def __init__(
-        self,
-        adapter: Adapter,
-        timeout: Timeout = DEFAULT,
-        _type: str = ModbusType.RTU.value,
-        slave_address: int | None = None,
-    ) -> None:
-        """
-        Modbus protocol
+def modbus_crc(_bytes: bytes) -> int:
+    """Calculate modbus CRC from the given buffer"""
+    # TODO : Implement
+    return 0
 
-        Parameters
-        ----------
-        adapter : Adapter
-            SerialPort or IP
-        timeout : Timeout
-        _type : str
-            Only used with SerialPort adapter
-            'RTU' : Modbus RTU (default)
-            'ASCII' : Modbus ASCII
-        """
-        super().__init__(adapter, timeout)
-        self._logger.debug("Initializing Modbus protocol...")
 
-        if isinstance(adapter, IP):
-            self._adapter: IP
-            self._adapter.set_default_port(MODBUS_TCP_DEFAULT_PORT)
-            self._modbus_type = ModbusType.TCP
-        elif isinstance(adapter, SerialPort):
-            self._modbus_type = ModbusType(_type)
-            assert slave_address is not None, "slave_address must be set"
-            raise NotImplementedError("Serialport (Modbus RTU) is not supported yet")
-        else:
-            raise ValueError("Invalid adapter")
+def _raise_if_error(sdu: bytes, exceptions: dict[int, str]) -> None:
+    if sdu == b"":
+        raise ModbusError("Empty response")
+    if sdu[0] & 0x80:
+        # There is an error
+        code = sdu[1]
+        if code not in exceptions:
+            raise ModbusError(f"Unexpected modbus error code: {code}")
+        raise ModbusError(f"{code:02X} : {exceptions[code]}")
 
-        self._slave_address = slave_address
 
-        self._transaction_id = 0
+class ModbusSDU:
+    """
+    Modbus Service Data Unit
 
-        # Connect the adapter if it wasn't done already
-        self._adapter.connect()
+    Subclasses of this contain either request or response fields to a modbus
+    frame
+    """
 
-    def _dm_to_pdu_address(self, dm_address: int) -> int:
-        """
-        Convert Modbus data model address to Modbus PDU address
+    def make_sdu(self) -> bytes:
+        """Generate a bytes array containing the SDU"""
+        raise ProtocolError("make_sdu() is not supported for this SDU")
 
-        - Modbus data model starts at address 1
-        - Modbus PDU addresses start at 0
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        """Generate a ModbusSDU instance from a given sdu buffer"""
+        raise ProtocolError("parse_sdu() is not supported for this SDU")
 
-        Modbus data model is the one specified in the devices datasheets
+    def exceptions(self) -> dict[int, str]:
+        """Return a dictionary of exceptions based on their integer code"""
+        return {}
 
-        Parameters
-        ----------
-        dm_address : int
-        """
-        if dm_address == 0:
-            raise ValueError("Address 0 is not valid in Modbus data model")
+    def _check_for_error(self, sdu: bytes) -> None:
+        """Check the given sdu buffer for an exception"""
+        _raise_if_error(sdu, self.exceptions())
 
-        return dm_address - 1
 
-    def _pdu_to_dm_address(self, pdu_address: int) -> int:
-        """
-        Convert Modbus PDU address to Modbus data model address
+class ModbusRequestSDU(ModbusSDU):
+    """
+    Base class for modbus request SDUs (Service Data Unit)
+    """
 
-        - Modbus data model starts at address 1
-        - Modbus PDU addresses start at 0
+    @abstractmethod
+    def function_code(self) -> FunctionCode:
+        """Return the function code of this modbus request"""
 
-        Modbus data model is the one specified in the devices datasheets
+    @classmethod
+    def expected_length(cls, pdu_length: int, modbus_type: ModbusType) -> int:
+        """
+        Return the length of the modbus SDU based on the length of the PDU and modbus type
 
         Parameters
         ----------
-        pdu_address : int
-        """
-        return pdu_address + 1
-
-    def _crc(self, _bytes: bytes) -> int:
-        # TODO : Implement
-        return 0
-
-    def _make_pdu(self, _bytes: bytes) -> bytes:
+        pdu_length : int
+        modbus_type : ModbusType
         """
-        Return PDU generated from bytes data
-        """
-        PROTOCOL_ID = 0
-        UNIT_ID = 0
-
-        if self._modbus_type == ModbusType.TCP:
-            # Return raw data
-            # output = _bytes
-            # Temporary :
-            length = len(_bytes) + 1  # unit_id is included
-            output = (
-                struct.pack(
-                    ENDIAN + "HHHB", self._transaction_id, PROTOCOL_ID, length, UNIT_ID
-                )
-                + _bytes
-            )
-            self._transaction_id += 1
+        if modbus_type == ModbusType.TCP:
+            output = pdu_length + 8
         else:
-            # Add slave address and error check
-            error_check = self._crc(_bytes)
-            output = (
-                struct.pack(ENDIAN + "B", self._slave_address)
-                + _bytes
-                + struct.pack(ENDIAN + "H", error_check)
-            )
-            if self._modbus_type.ASCII:
+            output = 1 + pdu_length + 2
+            if modbus_type == ModbusType.ASCII:
                 # Add header and trailer
-                output = self._ASCII_HEADER + output + self._ASCII_TRAILER
-
+                output += len(_ASCII_HEADER) + len(_ASCII_TRAILER)
         return output
 
-    def _raise_if_error(
-        self, response: bytes, exception_codes: ExceptionCodesType
-    ) -> None:
-        if response == b"":
-            raise RuntimeError("Empty response")
-        if response[0] & 0x80:
-            # There is an error
-            code = response[1]
-            if code not in exception_codes:
-                raise RuntimeError(f"Unexpected modbus error code: {code}")
-            else:
-                raise ModbusException(f"{code:02X} : {exception_codes[code]}")
-
-    def _is_error(self, response: bytes) -> bool:
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
         raise NotImplementedError()
 
-    def _error_code(self, response: bytes) -> int:
-        return response[1]
 
-    def _parse_pdu(self, _pdu: bytes | None) -> bytes:
-        """
-        Return data from PDU
-        """
-        if _pdu is None:
-            raise RuntimeError("Failed to read modbus data")
-        if self._modbus_type == ModbusType.TCP:
-            # Return raw data
-            # data = _pdu
-            data = _pdu[7:]
+# class ModbusResponseSDU(ModbusSDU):
+#     def make_sdu(self) -> bytes:
+#         """Generate a bytes array containing the SDU"""
+#         raise NotImplementedError("make_sdu() not implemented for this SDU")
 
-        else:
-            if self._modbus_type.ASCII:
-                # Remove header and trailer
-                _pdu = _pdu[len(self._ASCII_HEADER) : -len(self._ASCII_TRAILER)]
-            # Remove slave address and CRC and check CRC
 
-            data = _pdu[1:-2]
-            # Check CRC
-            # error_check = _pdu[-2:]
-            # TODO : Check here and raise exception
+class SerialLineOnlySDU(ModbusRequestSDU):
+    """
+    Marker class for serial line only Modbus function codes
+    """
 
-        return data
+    @abstractmethod
+    def exceptions(self) -> dict[int, str]: ...
 
-    def _length(self, pdu_length: int) -> int:
-        dummy_pdu = self._make_pdu(b"")
-        return len(dummy_pdu) + pdu_length
 
-    # Read Coils - 0x01
-    def read_coils(self, start_address: int, number_of_coils: int) -> list[bool]:
-        """
-        Read a defined number of coils starting at a set address
+# Read Coils - 0x01
+@dataclass
+class ReadCoilsSDU(ModbusRequestSDU):
+    """Read coils request."""
 
-        Parameters
-        ----------
-        start_address : int
-        number_of_coils : int
+    start_address: int
+    number_of_coils: int
 
-        Returns
-        -------
-        coils : list
-        """
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+        coils: list[bool]
 
-        EXCEPTIONS: ExceptionCodesType = {
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.READ_COILS
+
+    def exceptions(self) -> dict[int, str]:
+        return {
             1: "Function code not supported",
             2: "Invalid Start or end addresses",
             3: "Invalid quantity of outputs",
             4: "Couldn't read coils",
         }
 
-        assert (
-            1 <= number_of_coils <= MAX_DISCRETE_INPUTS
-        ), f"Invalid number of coils : {number_of_coils}"
-        assert (
-            MIN_ADDRESS <= start_address <= MAX_ADDRESS - number_of_coils + 1
-        ), f"Invalid start address : {start_address}"
+    def __post_init__(self) -> None:
+        _check_discrete_input_output_count(self.number_of_coils)
+        _check_address(self.start_address, MAX_ADDRESS - self.number_of_coils + 1)
 
-        query = struct.pack(
+    def make_sdu(self) -> bytes:
+        data = struct.pack(
             ENDIAN + "BHH",
             FunctionCode.READ_COILS.value,
-            self._dm_to_pdu_address(start_address),
-            number_of_coils,
+            _dm_to_pdu_address(self.start_address),
+            self.number_of_coils,
         )
 
-        n_coil_bytes = ceil(number_of_coils / 8)
-        pdu: bytes | None = self._adapter.query(
-            self._make_pdu(query),
-            # timeout=Timeout(continuation=1),
-            stop_conditions=[
-                Length(self._length(n_coil_bytes + 2)),
-                Continuation(time=1),
-            ],  # TODO : convert to multiple stop conditions here
-        )
-        response = self._parse_pdu(pdu)
-        self._raise_if_error(response, exception_codes=EXCEPTIONS)
+        return data
 
-        _, _, coil_bytes = struct.unpack(ENDIAN + f"BB{n_coil_bytes}s", response)
-        coils = bytes_to_bool_list(coil_bytes, number_of_coils)
-        return coils
+    def parse_sdu(self, sdu: bytes) -> Response:
+        super()._check_for_error(sdu)
+        _, n_bytes = struct.unpack(ENDIAN + "BB", sdu[:2])
+        coil_bytes = struct.unpack(ENDIAN + f"{n_bytes}s", sdu[2:])[0]
+        coils = bytes_to_bool_list(coil_bytes, self.number_of_coils)
+        return self.Response(coils)
 
-    def read_single_coil(self, address: int) -> bool:
-        """
-        Read a single coil at a specified address.
-        This is a wrapper for the read_coils method with the number of coils set to 1
 
-        Parameters
-        ----------
-        address : int
+# Read discrete inputs - 0x02
+@dataclass
+class ReadDiscreteInputs(ModbusRequestSDU):
+    """Read discrete inputs request."""
 
-        Returns
-        -------
-        coil : bool
-        """
-        coil = self.read_coils(start_address=address, number_of_coils=1)[0]
-        return coil
+    start_address: int
+    number_of_inputs: int
 
-    # Read Discrete inputs - 0x02
-    def read_discrete_inputs(
-        self, start_address: int, number_of_inputs: int
-    ) -> list[bool]:
-        """
-        Read a defined number of discrete inputs at a set starting address
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
 
-        Parameters
-        ----------
-        start_address : int
-        number_of_inputs : int
+        inputs: list[bool]
 
-        Returns
-        -------
-        inputs : list
-        List of booleans
-        """
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.READ_DISCRETE_INPUTS
 
-        EXCEPTIONS = {
+    def exceptions(self) -> dict[int, str]:
+        return {
             1: "Function code not supported",
             2: "Invalid Start or end addresses",
             3: "Invalid quantity of inputs",
             4: "Couldn't read inputs",
         }
 
-        assert (
-            1 <= number_of_inputs <= MAX_DISCRETE_INPUTS
-        ), f"Invalid number of inputs : {number_of_inputs}"
-        assert (
-            MIN_ADDRESS <= start_address <= MAX_ADDRESS - number_of_inputs + 1
-        ), f"Invalid start address : {start_address}"
+    def __post_init__(self) -> None:
+        _check_discrete_input_output_count(self.number_of_inputs)
+        _check_address(self.start_address, MAX_ADDRESS - self.number_of_inputs + 1)
 
-        query = struct.pack(
+    def make_sdu(self) -> bytes:
+        sdu = struct.pack(
             ENDIAN + "BHH",
-            FunctionCode.READ_DISCRETE_INPUTS.value,
-            self._dm_to_pdu_address(start_address),
-            number_of_inputs,
+            self.function_code().value,
+            _dm_to_pdu_address(self.start_address),
+            self.number_of_inputs,
         )
+        return sdu
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+
         byte_count = ceil(
-            number_of_inputs / 8
+            self.number_of_inputs / 8
         )  # pre-calculate the number of returned coil value bytes
-        response = self._parse_pdu(
-            self._adapter.query(
-                self._make_pdu(query),
-                stop_conditions=Length(self._length(byte_count + 2)),
-            )
-        )
-        self._raise_if_error(response, exception_codes=EXCEPTIONS)
-        _, _, data = struct.unpack(ENDIAN + f"BB{byte_count}s", response)
-        inputs = bytes_to_bool_list(data, number_of_inputs)
-        return inputs
 
-    # Read Holding Registers - 0x03
-    def read_holding_registers(
-        self, start_address: int, number_of_registers: int
-    ) -> list[int]:
-        """
-        Reads a defined number of registers starting at a set address
+        _, _, data = struct.unpack(ENDIAN + f"BB{byte_count}s", sdu)
+        inputs = bytes_to_bool_list(data, self.number_of_inputs)
 
-        Parameters
-        ----------
-        start_address : int
-        number_of_registers : int
-            1 to 125
+        return self.Response(inputs)
 
-        Returns
-        -------
-        registers : list
-        """
-        EXCEPTIONS = {
+
+# Read discrete inputs - 0x03
+@dataclass
+class ReadHoldingRegisters(ModbusRequestSDU):
+    """Read holding registers request."""
+
+    start_address: int
+    number_of_registers: int
+
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+        registers: list[int]
+
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.READ_HOLDING_REGISTERS
+
+    def exceptions(self) -> dict[int, str]:
+        return {
             1: "Function code not supported",
             2: "Invalid Start or end addresses",
             3: "Invalid quantity of registers",
             4: "Couldn't read registers",
         }
-        # Specification says 125, but the size would be exceeded over TCP. So 123 is safer
-        MAX_NUMBER_OF_REGISTERS = (AVAILABLE_PDU_SIZE - 2) // 2
 
-        assert (
-            MIN_ADDRESS <= start_address <= MAX_ADDRESS - number_of_registers + 1
-        ), f"Invalid start address : {start_address}"
+    def __post_init__(self) -> None:
+        _check_address(self.start_address, MAX_ADDRESS - self.number_of_registers + 1)
 
-        assert (
-            1 <= number_of_registers <= MAX_NUMBER_OF_REGISTERS
-        ), f"Invalid number of registers : {number_of_registers}"
-        query = struct.pack(
-            ENDIAN + "BHH",
-            FunctionCode.READ_HOLDING_REGISTERS.value,
-            self._dm_to_pdu_address(start_address),
-            number_of_registers,
-        )
-        response = self._parse_pdu(
-            self._adapter.query(
-                self._make_pdu(query),
-                stop_conditions=Length(self._length(2 + number_of_registers * 2)),
+        max_number_of_registers = (AVAILABLE_PDU_SIZE - 2) // 2
+
+        if not 1 <= self.number_of_registers <= max_number_of_registers:
+            raise ValueError(
+                f"Invalid number of registers : {self.number_of_registers}"
             )
+
+    def make_sdu(self) -> bytes:
+        sdu = struct.pack(
+            ENDIAN + "BHH",
+            self.function_code().value,
+            _dm_to_pdu_address(self.start_address),
+            self.number_of_registers,
         )
-        self._raise_if_error(response, exception_codes=EXCEPTIONS)
+        return sdu
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+
         _, _, registers_data = struct.unpack(
-            ENDIAN + f"BB{number_of_registers * 2}s", response
+            ENDIAN + f"BB{self.number_of_registers * 2}s", sdu
         )
         registers = list(
-            struct.unpack(ENDIAN + "H" * number_of_registers, registers_data)
+            struct.unpack(ENDIAN + "H" * self.number_of_registers, registers_data)
         )
-        return registers
 
-    def read_multi_register_value(
-        self,
-        address: int,
-        n_registers: int,
-        value_type: str,
-        byte_order: str = Endian.BIG.value,
-        word_order: str = Endian.BIG.value,
-        encoding: str = "utf-8",
-        padding: int | None = 0,
-    ) -> str | bytes | int | float:
-        """
-        Read an integer, a float, or a string over multiple registers
+        return self.Response(registers)
 
-        Parameters
-        ----------
-        address : int
-            Address of the first register
-        n_registers : int
-            Number of registers (half the number of bytes)
-        value_type : str
-            Type to which the value will be cast
-                'int' : signed integer
-                'uint' : unsigned integer
-                'float' : float or double
-                'string' : string
-                'array' : Bytes array
-            Each type will be adapted based on the number of bytes (_bytes parameter)
-        byte_order : str
-            Byte order, 'big' means the high bytes will come first, 'little' means the low bytes will come first
-            Byte order inside a register (2 bytes) is always big as per Modbus specification (4.2 Data Encoding)
-        encoding : str
-            String encoding (if used). UTF-8 by default
-        padding : int | None
-            String padding, None to return the raw string
-        Returns
-        -------
-        data : any
-        """
-        type_cast = TypeCast(value_type)
-        _byte_order = Endian(byte_order)
-        if type_cast.is_number():
-            _word_order = Endian(word_order)
-        else:
-            _word_order = Endian.BIG
-        # Read N registers
-        registers = self.read_holding_registers(
-            start_address=address, number_of_registers=n_registers
-        )
-        # Create a buffer
-        to_bytes_endian = Endian.BIG if _byte_order == _word_order else Endian.LITTLE
-        buffer = b"".join(
-            [x.to_bytes(2, byteorder=to_bytes_endian.value) for x in registers]
-        )
-        # Use struct_format to convert to the corresponding value directly
-        # Swap the buffer accordingly
-        data: bytes | int | float = struct.unpack(
-            endian_symbol[_word_order] + struct_format(type_cast, n_registers * 2),
-            buffer,
-        )[0]
 
-        # If data is a string, do additionnal processing
-        output: bytes | int | float | str
-        if type_cast == TypeCast.STRING:
-            data = cast(bytes, data)
-            # If null termination is enabled, remove any \0
-            if padding is not None and padding in data:
-                data = data[: data.index(padding)]
-            # Cast
-            output = data.decode(encoding)
-        else:
-            output = data
+# Write Single coil - 0x05
+@dataclass
+class WriteSingleCoilSDU(ModbusRequestSDU):
+    """Write single coil request."""
 
-        return output
+    address: int
+    status: bool
 
-    def write_multi_register_value(
-        self,
-        address: int,
-        n_registers: int,
-        value_type: str,
-        value: str | bytes | int | float,
-        byte_order: str = Endian.BIG.value,
-        word_order: str = Endian.BIG.value,
-        encoding: str = "utf-8",
-        padding: int = 0,
-    ) -> None:
-        """
-        Write an integer, a float, or a string over multiple registers
+    _ON_VALUE = 0xFF00
+    _OFF_VALUE = 0x0000
+
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.WRITE_SINGLE_COIL
+
+    def exceptions(self) -> dict[int, str]:
+        return {
+            1: "Function code not supported",
+            2: "Invalid address",
+            3: "Invalid value",
+            4: "Couldn't set coil output",
+        }
+
+    def __post_init__(self) -> None:
+        _check_address(self.address)
+
+    def make_sdu(self) -> bytes:
+        sdu = struct.pack(
+            ENDIAN + "BHH",
+            FunctionCode.WRITE_SINGLE_COIL.value,
+            _dm_to_pdu_address(self.address),
+            self._ON_VALUE if self.status else self._OFF_VALUE,
+        )
+        return sdu
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+        return self.Response()
+
+
+@dataclass
+class ReadInputRegistersSDU(ModbusRequestSDU):
+    """Read input registers request."""
+
+    start_address: int
+    number_of_registers: int
+
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+        registers: list[int]
+
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.READ_INPUT_REGISTERS
+
+    def exceptions(self) -> dict[int, str]:
+        return {
+            1: "Function code not supported",
+            2: "Invalid Start or end addresses",
+            3: "Invalid quantity of registers",
+            4: "Couldn't read registers",
+        }
+
+    def __post_init__(self) -> None:
+        _check_address(self.start_address, MAX_ADDRESS - self.number_of_registers + 1)
+
+        max_number_of_registers = (AVAILABLE_PDU_SIZE - 2) // 2
+
+        if not 1 <= self.number_of_registers <= max_number_of_registers:
+            raise ValueError(
+                f"Invalid number of registers : {self.number_of_registers}"
+            )
+
+    def make_sdu(self) -> bytes:
+        sdu = struct.pack(
+            ENDIAN + "BHH",
+            self.function_code().value,
+            _dm_to_pdu_address(self.start_address),
+            self.number_of_registers,
+        )
+        return sdu
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+
+        _, _, registers_data = struct.unpack(
+            ENDIAN + f"BB{self.number_of_registers * 2}s", sdu
+        )
+        registers = list(
+            struct.unpack(ENDIAN + "H" * self.number_of_registers, registers_data)
+        )
+
+        return self.Response(registers)
+
+
+@dataclass
+class WriteSingleRegisterSDU(ModbusRequestSDU):
+    """Write single register request."""
+
+    address: int
+    value: int
+
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.WRITE_SINGLE_REGISTER
+
+    def exceptions(self) -> dict[int, str]:
+        return {
+            1: "Function code not supported",
+            2: "Invalid address",
+            3: "Invalid register value",
+            4: "Couldn't write register",
+        }
+
+    def __post_init__(self) -> None:
+        _check_address(self.address)
+        if not 0 <= self.value <= 0xFFFF:
+            raise ValueError(f"Invalid register value : {self.value}")
+
+    def make_sdu(self) -> bytes:
+        sdu = struct.pack(
+            ENDIAN + "BHH",
+            self.function_code().value,
+            _dm_to_pdu_address(self.address),
+            self.value,
+        )
+        return sdu
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+        if sdu != self.make_sdu():
+            raise ProtocolReadError(
+                f"Response ({sdu!r}) should match query ({self.make_sdu()!r})"
+            )
+        return self.Response()
+
+
+@dataclass
+class ReadExceptionStatusSDU(SerialLineOnlySDU):
+    """Read exception status request (serial only)."""
+
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+        status: int
+
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.READ_EXCEPTION_STATUS
+
+    def exceptions(self) -> dict[int, str]:
+        return {
+            1: "Function code not supported",
+            4: "Couldn't read exception status",
+        }
+
+    def make_sdu(self) -> bytes:
+        return struct.pack(ENDIAN + "B", self.function_code().value)
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+        _, status = cast(tuple[int, int], struct.unpack(ENDIAN + "BB", sdu))
+        return self.Response(status)
+
+
+@dataclass
+class DiagnosticsSDU(SerialLineOnlySDU):
+    """Diagnostics request (serial only)."""
+
+    code: DiagnosticsCode
+    subfunction_data: bytes
+    return_subfunction_bytes: int
+    check_response: bool = True
+
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+        data: bytes
+
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.DIAGNOSTICS
+
+    def exceptions(self) -> dict[int, str]:
+        return {
+            1: "Unsuported function code or sub-function code",
+            3: "Invalid data value",
+            4: "Diagnostic error",
+        }
+
+    def make_sdu(self) -> bytes:
+        return (
+            struct.pack(ENDIAN + "BH", self.function_code().value, self.code.value)
+            + self.subfunction_data
+        )
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+
+        if self.return_subfunction_bytes == 0:
+            returned_function, returned_subfunction_integer = struct.unpack(
+                ENDIAN + "BH", sdu
+            )
+            subfunction_returned_data = b""
+        else:
+            (
+                returned_function,
+                returned_subfunction_integer,
+                subfunction_returned_data,
+            ) = cast(
+                tuple[int, int, bytes],
+                struct.unpack(ENDIAN + f"BH{self.return_subfunction_bytes}s", sdu),
+            )
+
+        if self.check_response:
+            returned_subfunction = DiagnosticsCode(returned_subfunction_integer)
+
+            if returned_function != self.function_code().value:
+                raise ProtocolReadError(
+                    f"Invalid returned function code : {returned_function}"
+                )
+            if returned_subfunction != self.code:
+                raise ProtocolReadError(
+                    f"Invalid returned subfunction code : {returned_subfunction}"
+                )
+
+        return self.Response(subfunction_returned_data)
+
+
+@dataclass
+class GetCommEventCounterSDU(SerialLineOnlySDU):
+    """Get communication event counter request (serial only)."""
+
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+        status: int
+        event_count: int
+
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.GET_COMM_EVENT_COUNTER
+
+    def exceptions(self) -> dict[int, str]:
+        return {
+            1: "Function code not supported",
+            4: "Couldn't get comm event counter",
+        }
+
+    def make_sdu(self) -> bytes:
+        return struct.pack(ENDIAN + "B", self.function_code().value)
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+        _, status, event_count = struct.unpack(ENDIAN + "BHH", sdu)
+        return self.Response(status, event_count)
+
+
+@dataclass
+class GetCommEventLogSDU(SerialLineOnlySDU):
+    """Get communication event log request (serial only)."""
+
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+        status: int
+        event_count: int
+        message_count: int
+        events: bytes
+
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.GET_COMM_EVENT_LOG
+
+    def exceptions(self) -> dict[int, str]:
+        return {
+            1: "Function code not supported",
+            4: "Couldn't get comm event log",
+        }
+
+    def make_sdu(self) -> bytes:
+        return struct.pack(ENDIAN + "B", self.function_code().value)
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+        _, byte_count = struct.unpack(ENDIAN + "BB", sdu[:2])
+        status, event_count, message_count = struct.unpack(ENDIAN + "HHH", sdu[2:8])
+        events = sdu[8 : 8 + (byte_count - 6)]
+        return self.Response(status, event_count, message_count, events)
+
+
+@dataclass
+class WriteMultipleCoilsSDU(ModbusRequestSDU):
+    """Write multiple coils request."""
+
+    start_address: int
+    values: list[bool]
+
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.WRITE_MULTIPLE_COILS
+
+    def exceptions(self) -> dict[int, str]:
+        return {
+            1: "Function code not supported",
+            2: "Invalid start and/or end addresses",
+            3: "Invalid number of outputs and/or byte count",
+            4: "Couldn't write outputs",
+        }
+
+    def __post_init__(self) -> None:
+        number_of_coils = len(self.values)
+        _check_discrete_input_output_count(number_of_coils)
+        _check_address(self.start_address, MAX_ADDRESS - number_of_coils + 1)
+
+    def make_sdu(self) -> bytes:
+        number_of_coils = len(self.values)
+        byte_count = ceil(number_of_coils / 8)
+        sdu = struct.pack(
+            ENDIAN + f"BHHB{byte_count}s",
+            self.function_code().value,
+            _dm_to_pdu_address(self.start_address),
+            number_of_coils,
+            byte_count,
+            bool_list_to_bytes(self.values),
+        )
+        return sdu
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+
+        _, start_address, coils_written = struct.unpack(ENDIAN + "BHH", sdu)
+        if coils_written != len(self.values):
+            raise ProtocolError(
+                f"Number of coils written ({coils_written}) doesn't match expected "
+                f"value : {len(self.values)}"
+            )
+        if start_address != _dm_to_pdu_address(self.start_address):
+            raise ProtocolReadError(
+                f"Start address mismatch : {start_address} != "
+                "{_dm_to_pdu_address(self.start_address)}"
+            )
+        return self.Response()
+
+
+@dataclass
+class WriteMultipleRegistersSDU(ModbusRequestSDU):
+    """Write multiple registers request."""
+
+    start_address: int
+    values: list[int]
+
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.WRITE_MULTIPLE_REGISTERS
+
+    def exceptions(self) -> dict[int, str]:
+        return {
+            1: "Function code not supported",
+            2: "Invalid start and/or end addresses",
+            3: "Invalid number of outputs and/or byte count",
+            4: "Couldn't write outputs",
+        }
+
+    def __post_init__(self) -> None:
+        max_number_of_registers = (AVAILABLE_PDU_SIZE - 6) // 2
+
+        if len(self.values) == 0:
+            raise ValueError("Empty register list")
+
+        if len(self.values) > max_number_of_registers:
+            raise ValueError(
+                f"Cannot set more than {max_number_of_registers} registers at a time"
+            )
+
+        _check_address(self.start_address, MAX_ADDRESS - len(self.values) + 1)
+
+    def make_sdu(self) -> bytes:
+        byte_count = 2 * len(self.values)
+        sdu = struct.pack(
+            ENDIAN + f"BHHB{byte_count // 2}H",
+            self.function_code().value,
+            _dm_to_pdu_address(self.start_address),
+            byte_count // 2,
+            byte_count,
+            *self.values,
+        )
+        return sdu
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+
+        _, start_address, registers_written = struct.unpack(ENDIAN + "BHH", sdu)
+        if registers_written != len(self.values):
+            raise ProtocolError(
+                f"Number of registers written ({registers_written}) doesn't match expected "
+                f"value : {len(self.values)}"
+            )
+        if start_address != _dm_to_pdu_address(self.start_address):
+            raise ProtocolReadError(
+                f"Start address mismatch : {start_address} != "
+                "{_dm_to_pdu_address(self.start_address)}"
+            )
+        return self.Response()
+
+
+@dataclass
+class ReportServerIdSDU(SerialLineOnlySDU):
+    """Report server ID request (serial only)."""
+
+    server_id_length: int
+    additional_data_length: int
+
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+        server_id: bytes
+        run_indicator_status: bool
+        additional_data: bytes
+
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.REPORT_SERVER_ID
+
+    def exceptions(self) -> dict[int, str]:
+        return {
+            1: "Function code not supported",
+            4: "Couldn't report slave ID",
+        }
+
+    def make_sdu(self) -> bytes:
+        return struct.pack(ENDIAN + "B", self.function_code().value)
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+        _, byte_count = struct.unpack(ENDIAN + "BB", sdu[:2])
+        expected = self.server_id_length + 1 + self.additional_data_length
+        if byte_count != expected:
+            raise ProtocolReadError(
+                f"Invalid byte count : {byte_count}, expected {expected}"
+            )
+        start = 2
+        end = start + self.server_id_length
+        server_id = sdu[start:end]
+        run_indicator_status = sdu[end] == 0xFF
+        additional_data = sdu[end + 1 : end + 1 + self.additional_data_length]
+        return self.Response(server_id, run_indicator_status, additional_data)
+
+
+@dataclass
+class ReadFileRecordSDU(ModbusRequestSDU):
+    """Read file record request."""
+
+    records: list[tuple[int, int, int]]
+
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+        records_data: list[bytes]
+
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.READ_FILE_RECORD
+
+    def exceptions(self) -> dict[int, str]:
+        return {
+            1: "Function code not supported",
+            2: "Invalid parameters",
+            3: "Invalid byte count",
+            4: "Couldn't read records",
+        }
+
+    def __post_init__(self) -> None:
+        size_limit = 253
+        query_size = 2 + 7 * len(self.records)
+        response_size = 2 + len(self.records) + sum(2 * r[2] for r in self.records)
+        if query_size > size_limit:
+            raise ValueError(f"Number of records is too high : {len(self.records)}")
+        if response_size > size_limit:
+            raise ValueError(
+                f"Sum of records lenghts is too high : {sum(r[2] for r in self.records)}"
+            )
+
+    def make_sdu(self) -> bytes:
+        reference_type = 6
+        sub_req_buffer = b""
+        for file_number, record_number, record_length in self.records:
+            sub_req_buffer += struct.pack(
+                ENDIAN + "BHHH",
+                reference_type,
+                file_number,
+                record_number,
+                record_length,
+            )
+
+        byte_count = len(sub_req_buffer)
+        sdu = struct.pack(
+            ENDIAN + f"BB{byte_count}s",
+            self.function_code().value,
+            byte_count,
+            sub_req_buffer,
+        )
+        return sdu
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+        _, byte_count = struct.unpack(ENDIAN + "BB", sdu[:2])
+        records_data: list[bytes] = []
+        offset = 2
+        end = 2 + byte_count
+        while offset < end:
+            length = sdu[offset]
+            reference_type = sdu[offset + 1]
+            if reference_type != 6:
+                raise ProtocolReadError(f"Invalid reference type : {reference_type}")
+            data_start = offset + 2
+            data_end = data_start + length - 1
+            records_data.append(sdu[data_start:data_end])
+            offset = data_end
+
+        return self.Response(records_data)
+
+
+@dataclass
+class WriteFileRecordSDU(ModbusRequestSDU):
+    """Write file record request."""
+
+    records: list[tuple[int, int, bytes]]
+
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.WRITE_FILE_RECORD
+
+    def exceptions(self) -> dict[int, str]:
+        return {
+            1: "Function code not supported",
+            2: "Invalid parameters",
+            3: "Invalid byte count",
+            4: "Couldn't write records",
+        }
+
+    def __post_init__(self) -> None:
+        if isinstance(self.records, tuple):
+            self.records = [self.records]
+        elif not isinstance(self.records, list):
+            raise TypeError(f"Invalid records type : {self.records}")
+
+    def make_sdu(self) -> bytes:
+        reference_type = 6
+        sub_req_buffer = b""
+
+        for file_number, record_number, data in self.records:
+            sub_req_buffer += struct.pack(
+                ENDIAN + f"BHHH{len(data)}s",
+                reference_type,
+                file_number,
+                record_number,
+                len(data) // 2,
+                data,
+            )
+
+        sdu = struct.pack(
+            ENDIAN + f"BB{len(sub_req_buffer)}s",
+            self.function_code().value,
+            len(sub_req_buffer),
+            sub_req_buffer,
+        )
+        return sdu
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+        if sdu != self.make_sdu():
+            raise ProtocolReadError("Response different from query")
+        return self.Response()
+
+
+@dataclass
+class MaskWriteRegisterSDU(ModbusRequestSDU):
+    """Mask write register request."""
+
+    address: int
+    and_mask: int
+    or_mask: int
+
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.MASK_WRITE_REGISTER
+
+    def exceptions(self) -> dict[int, str]:
+        return {
+            1: "Function code not supported",
+            2: "Invalid register address",
+            3: "Invalid AND/OR mask",
+            4: "Couldn't write register",
+        }
+
+    def __post_init__(self) -> None:
+        _check_address(self.address)
+
+    def make_sdu(self) -> bytes:
+        sdu = struct.pack(
+            ENDIAN + "BHHH",
+            self.function_code().value,
+            _dm_to_pdu_address(self.address),
+            self.and_mask,
+            self.or_mask,
+        )
+        return sdu
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+        if sdu != self.make_sdu():
+            raise ProtocolReadError(
+                f"Response ({sdu!r}) should match query ({self.make_sdu()!r})"
+            )
+        return self.Response()
+
+
+@dataclass
+class ReadWriteMultipleRegistersSDU(ModbusRequestSDU):
+    """Read/write multiple registers request."""
+
+    read_starting_address: int
+    number_of_read_registers: int
+    write_starting_address: int
+    write_values: list[int]
+
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+        read_values: list[int]
+
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.READ_WRITE_MULTIPLE_REGISTERS
+
+    def exceptions(self) -> dict[int, str]:
+        return {
+            1: "Function code not supported",
+            2: "Invalid read/write start/end address",
+            3: "Invalid quantity of read/write and/or byte count",
+            4: "Couldn't read and/or write registers",
+        }
+
+    def __post_init__(self) -> None:
+        max_number_read_registers = (AVAILABLE_PDU_SIZE - 2) // 2
+        max_numbers_write_registers = (AVAILABLE_PDU_SIZE - 10) // 2
+
+        if not 1 <= self.number_of_read_registers <= max_number_read_registers:
+            raise ValueError(
+                f"Invalid number of read registers : {self.number_of_read_registers}"
+            )
+
+        if not 1 <= len(self.write_values) <= max_numbers_write_registers:
+            raise ValueError(
+                f"Invalid number of write registers : {self.number_of_read_registers}"
+            )
+
+        _check_address(
+            self.read_starting_address,
+            MAX_ADDRESS - self.number_of_read_registers + 1,
+        )
+        _check_address(
+            self.write_starting_address, MAX_ADDRESS - len(self.write_values) + 1
+        )
+
+    def make_sdu(self) -> bytes:
+        sdu = struct.pack(
+            ENDIAN + f"BHHHHB{len(self.write_values)}H",
+            self.function_code().value,
+            _dm_to_pdu_address(self.read_starting_address),
+            self.number_of_read_registers,
+            _dm_to_pdu_address(self.write_starting_address),
+            len(self.write_values),
+            len(self.write_values) * 2,
+            *self.write_values,
+        )
+        return sdu
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+        _, byte_count = struct.unpack(ENDIAN + "BB", sdu[:2])
+        expected = self.number_of_read_registers * 2
+        if byte_count != expected:
+            raise ProtocolReadError(
+                f"Invalid byte count : {byte_count}, expected {expected}"
+            )
+        read_values = list(
+            struct.unpack(ENDIAN + f"{self.number_of_read_registers}H", sdu[2:])
+        )
+        return self.Response(read_values)
+
+
+@dataclass
+class ReadFifoQueueSDU(ModbusRequestSDU):
+    """Read FIFO queue request."""
+
+    fifo_address: int
+
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+        values: list[int]
+
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.READ_FIFO_QUEUE
+
+    def exceptions(self) -> dict[int, str]:
+        return {
+            1: "Function code not supported",
+            2: "Invalid FIFO address",
+            3: "Invalid FIFO count (>31)",
+            4: "Couldn't read FIFO queue",
+        }
+
+    def __post_init__(self) -> None:
+        _check_address(self.fifo_address)
+
+    def make_sdu(self) -> bytes:
+        return struct.pack(
+            ENDIAN + "BH",
+            self.function_code().value,
+            _dm_to_pdu_address(self.fifo_address),
+        )
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+        _, byte_count = struct.unpack(ENDIAN + "BH", sdu[:3])
+        fifo_count = struct.unpack(ENDIAN + "H", sdu[3:5])[0]
+        register_count = byte_count // 2 - 1
+        if fifo_count != register_count:
+            raise ProtocolReadError(
+                f"FIFO count mismatch : {fifo_count} != {register_count}"
+            )
+        values = list(struct.unpack(ENDIAN + f"{register_count}H", sdu[5:]))
+        return self.Response(values)
+
+
+@dataclass
+class EncapsulatedInterfaceTransportSDU(ModbusRequestSDU):
+    """Encapsulated interface transport request."""
+
+    mei_type: int
+    mei_data: bytes
+    extra_exceptions: dict[int, str] | None = None
+
+    @dataclass
+    class Response(ModbusSDU):
+        """Response data."""
+
+        data: bytes
+
+    def function_code(self) -> FunctionCode:
+        return FunctionCode.ENCAPSULATED_INTERFACE_TRANSPORT
+
+    def exceptions(self) -> dict[int, str]:
+        exceptions = {1: "Function code not supported"}
+        if self.extra_exceptions is not None:
+            exceptions.update(self.extra_exceptions)
+        return exceptions
+
+    def make_sdu(self) -> bytes:
+        return struct.pack(
+            ENDIAN + f"BB{len(self.mei_data)}s",
+            self.function_code().value,
+            self.mei_type,
+            self.mei_data,
+        )
+
+    def parse_sdu(self, sdu: bytes) -> ModbusSDU:
+        self._check_for_error(sdu)
+        return self.Response(sdu[2:])
+
+
+class ModbusFrame(ProtocolFrame[ModbusSDU]):
+    """Modbus frame containing a ModbusSDU"""
+
+    payload: ModbusSDU
+
+    def __str__(self) -> str:
+        return f"ModbusFrame({self.payload})"
+
+
+# pylint: disable=too-many-public-methods
+class Modbus(Protocol[ModbusSDU]):
+    """
+    Modbus protocol
+
+    Parameters
+    ----------
+    adapter : Adapter
+        SerialPort or IP
+    timeout : Timeout
+    _type : str
+        Only used with SerialPort adapter
+        'RTU' : Modbus RTU (default)
+        'ASCII' : Modbus ASCII
+    """
+
+    def __init__(
+        self,
+        adapter: Adapter,
+        timeout: Timeout | None | EllipsisType = ...,
+        _type: str = ModbusType.RTU.value,
+        slave_address: int | None = None,
+    ) -> None:
+        super().__init__(adapter, timeout)
+        self._logger.debug("Initializing Modbus protocol...")
+
+        if isinstance(adapter, IP):
+            self._adapter: IP
+            self._adapter.set_default_port(MODBUS_TCP_DEFAULT_PORT)
+            self._modbus_type = ModbusType.TCP
+        elif isinstance(adapter, SerialPort):
+            self._modbus_type = ModbusType(_type)
+            if slave_address is None:
+                raise ValueError("slave_address must be set")
+            raise NotImplementedError("Serialport (Modbus RTU) is not supported yet")
+        else:
+            raise ValueError("Invalid adapter")
+
+        self._slave_address = slave_address
+
+        self._last_sdu: ModbusSDU | None = None
+        self._transaction_id = 0
+
+    def _default_timeout(self) -> Timeout | None:
+        return Timeout(response=1, action="error")
+
+    def _on_event(self, event: AdapterEvent) -> None: ...
+
+    def _protocol_to_adapter(self, protocol_payload: ModbusSDU) -> bytes:
+        if isinstance(protocol_payload, SerialLineOnlySDU):
+            if self._modbus_type == ModbusType.TCP:
+                raise ProtocolError("This function cannot be used with Modbus TCP")
+
+        sdu = protocol_payload.make_sdu()
+
+        if self._modbus_type == ModbusType.TCP:
+            # Return raw data
+            length = len(sdu) + 1  # unit_id is included
+            output = (
+                struct.pack(
+                    ENDIAN + "HHHB", self._transaction_id, _PROTOCO_ID, length, _UNIT_ID
+                )
+                + sdu
+            )
+        else:
+            # Add slave address and error check
+            error_check = modbus_crc(sdu)
+            output = (
+                struct.pack(ENDIAN + "B", self._slave_address)
+                + sdu
+                + struct.pack(ENDIAN + "H", error_check)
+            )
+            if self._modbus_type == ModbusType.ASCII:
+                # Add header and trailer
+                output = _ASCII_HEADER + output + _ASCII_TRAILER
+
+        self._transaction_id += 1
+
+        self._last_sdu = protocol_payload
+        return output
+
+    def _adapter_to_protocol(
+        self, adapter_frame: AdapterFrame
+    ) -> ProtocolFrame[ModbusSDU]:
+        pdu = adapter_frame.get_payload()
+
+        if self._modbus_type == ModbusType.TCP:
+            # transaction_id, protocol_id, length, unit_id = struct.unpack(
+            #     "HHHB",
+            #     pdu[:7]
+            # )
+            data = pdu[7:]
+            # len(data) should match length variable
+        else:
+            if self._modbus_type == ModbusType.ASCII:
+                # Remove header and trailer
+                pdu = pdu[len(_ASCII_HEADER) : -len(_ASCII_TRAILER)]
+            # Remove slave address and CRC and check CRC
+
+            # slave_address = pdu[0]
+            data = pdu[1:-2]
+            # crc = pdu[-2:] # TODO : Check CRC
+
+        if self._last_sdu is None:
+            raise ModbusError("Cannot read without prior write")
+
+        # It is necessary to know the previous SDU because some information cannot
+        # be parsed from the response only (like the number of coils from a read_coils
+        # command)
+        sdu = self._last_sdu.parse_sdu(data)
+
+        return ModbusFrame(
+            stop_timestamp=adapter_frame.stop_timestamp,
+            stop_condition_type=adapter_frame.stop_condition_type,
+            previous_read_buffer_used=adapter_frame.previous_read_buffer_used,
+            response_delay=adapter_frame.response_delay,
+            payload=sdu,
+        )
+
+    # ┌────────────┐
+    # │ Public API │
+    # └────────────┘
+
+    # Read Coils - 0x01
+    def read_coils(self, start_address: int, number_of_coils: int) -> list[bool]:
+        """
+        Read a defined number of coils starting at a set address
+
+        Parameters
+        ----------
+        start_address : int
+        number_of_coils : int
+
+        Returns
+        -------
+        coils : list
+        """
+        payload = ReadCoilsSDU(
+            start_address=start_address, number_of_coils=number_of_coils
+        )
+
+        output = cast(ReadCoilsSDU.Response, self.query(payload))
+
+        return output.coils
+
+    async def aread_coils(self, start_address: int, number_of_coils: int) -> list[bool]:
+        """
+        Asynchronously read a defined number of coils starting at a set address
+
+        Parameters
+        ----------
+        start_address : int
+        number_of_coils : int
+
+        Returns
+        -------
+        coils : list
+        """
+
+        payload = ReadCoilsSDU(
+            start_address=start_address, number_of_coils=number_of_coils
+        )
+
+        output = cast(ReadCoilsSDU.Response, await self.aquery(payload))
+
+        return output.coils
+
+    # This is a wrapper for the read_coils method
+    def read_single_coil(self, address: int) -> bool:
+        """
+        Read a single coil at a specified address.
+        This is a wrapper for the read_coils method with the number of coils set to 1
+
+        Parameters
+        ----------
+        address : int
+
+        Returns
+        -------
+        coil : bool
+        """
+        coil = self.read_coils(start_address=address, number_of_coils=1)[0]
+        return coil
+
+    async def aread_single_coil(self, address: int) -> bool:
+        """
+        Asynchronously read a single coil at a specified address.
+        This is a wrapper for the read_coils method with the number of coils set to 1
+
+        Parameters
+        ----------
+        address : int
+
+        Returns
+        -------
+        coil : bool
+        """
+        coil = (await self.aread_coils(start_address=address, number_of_coils=1))[0]
+        return coil
+
+    # Read Discrete inputs - 0x02
+    def read_discrete_inputs(
+        self, start_address: int, number_of_inputs: int
+    ) -> list[bool]:
+        """
+        Read a defined number of discrete inputs at a set starting address
+
+        Parameters
+        ----------
+        start_address : int
+        number_of_inputs : int
+
+        Returns
+        -------
+        inputs : list
+        List of booleans
+        """
+
+        payload = ReadDiscreteInputs(
+            start_address=start_address, number_of_inputs=number_of_inputs
+        )
+
+        output = cast(ReadDiscreteInputs.Response, self.query(payload))
+
+        return output.inputs
+
+    async def aread_discrete_inputs(
+        self, start_address: int, number_of_inputs: int
+    ) -> list[bool]:
+        """
+        Read a defined number of discrete inputs at a set starting address
+
+        Parameters
+        ----------
+        start_address : int
+        number_of_inputs : int
+
+        Returns
+        -------
+        inputs : list
+        List of booleans
+        """
+
+        payload = ReadDiscreteInputs(
+            start_address=start_address, number_of_inputs=number_of_inputs
+        )
+
+        output = cast(ReadDiscreteInputs.Response, await self.aquery(payload))
+
+        return output.inputs
+
+    # Read Holding Registers - 0x03
+    def read_holding_registers(
+        self, start_address: int, number_of_registers: int
+    ) -> list[int]:
+        """
+        Reads a defined number of registers starting at a set address
+
+        Parameters
+        ----------
+        start_address : int
+        number_of_registers : int
+            1 to 125
+
+        Returns
+        -------
+        registers : list
+        """
+
+        payload = ReadHoldingRegisters(
+            start_address=start_address, number_of_registers=number_of_registers
+        )
+
+        output = cast(ReadHoldingRegisters.Response, self.query(payload))
+
+        return output.registers
+
+    async def aread_holding_registers(
+        self, start_address: int, number_of_registers: int
+    ) -> list[int]:
+        """
+        Asynchronously Reads a defined number of registers starting at a set address
+
+        Parameters
+        ----------
+        start_address : int
+        number_of_registers : int
+            1 to 125
+
+        Returns
+        -------
+        registers : list
+        """
+
+        payload = ReadHoldingRegisters(
+            start_address=start_address, number_of_registers=number_of_registers
+        )
+
+        output = cast(ReadHoldingRegisters.Response, await self.aquery(payload))
+
+        return output.registers
+
+    def _parse_multi_register_value(
+        self,
+        n_registers: int,
+        registers: list[int],
+        value_type: str,
+        *,
+        byte_order: str = Endian.BIG.value,
+        word_order: str = Endian.BIG.value,
+        encoding: str = "utf-8",
+        padding: int | None = 0,
+    ) -> str | bytes | int | float:
+
+        type_cast = TypeCast(value_type)
+        _byte_order = Endian(byte_order)
+        if type_cast.is_number():
+            _word_order = Endian(word_order)
+        else:
+            _word_order = Endian.BIG
+        # Create a buffer
+        to_bytes_endian = Endian.BIG if _byte_order == _word_order else Endian.LITTLE
+        buffer = b"".join(
+            [x.to_bytes(2, byteorder=to_bytes_endian.value) for x in registers]
+        )
+        # Use struct_format to convert to the corresponding value directly
+        # Swap the buffer accordingly
+        data: bytes | int | float = struct.unpack(
+            endian_symbol[_word_order] + struct_format(type_cast, n_registers * 2),
+            buffer,
+        )[0]
+
+        # If data is a string, do additionnal processing
+        output: bytes | int | float | str
+        if type_cast == TypeCast.STRING:
+            data = cast(bytes, data)
+            # If null termination is enabled, remove any \0
+            if padding is not None and padding in data:
+                data = data[: data.index(padding)]
+            # Cast
+            output = data.decode(encoding)
+        else:
+            output = data
+
+        return output
+
+    def read_multi_register_value(
+        self,
+        address: int,
+        n_registers: int,
+        value_type: str,
+        *,
+        byte_order: str = Endian.BIG.value,
+        word_order: str = Endian.BIG.value,
+        encoding: str = "utf-8",
+        padding: int | None = 0,
+    ) -> str | bytes | int | float:
+        """
+        Read an integer, a float, or a string over multiple registers
+
+        Parameters
+        ----------
+        address : int
+            Address of the first register
+        n_registers : int
+            Number of registers (half the number of bytes)
+        value_type : str
+            Type to which the value will be cast
+                'int' : signed integer
+                'uint' : unsigned integer
+                'float' : float or double
+                'string' : string
+                'array' : Bytes array
+            Each type will be adapted based on the number of bytes (_bytes parameter)
+        byte_order : str
+            Byte order, 'big' means the high bytes will come first, 'little' means the low bytes
+            will come first
+            Byte order inside a register (2 bytes) is always big as per
+            Modbus specification (4.2 Data Encoding)
+        encoding : str
+            String encoding (if used). UTF-8 by default
+        padding : int | None
+            String padding, None to return the raw string
+        Returns
+        -------
+        data : any
+        """
+        # Read N registers
+        registers = self.read_holding_registers(
+            start_address=address, number_of_registers=n_registers
+        )
+
+        return self._parse_multi_register_value(
+            n_registers=n_registers,
+            registers=registers,
+            value_type=value_type,
+            byte_order=byte_order,
+            word_order=word_order,
+            encoding=encoding,
+            padding=padding,
+        )
+
+    async def aread_multi_register_value(
+        self,
+        address: int,
+        n_registers: int,
+        value_type: str,
+        *,
+        byte_order: str = Endian.BIG.value,
+        word_order: str = Endian.BIG.value,
+        encoding: str = "utf-8",
+        padding: int | None = 0,
+    ) -> str | bytes | int | float:
+        """
+        Asynchronously read an integer, a float, or a string over multiple registers
 
         Parameters
         ----------
@@ -624,26 +1798,53 @@ class Modbus(Protocol):
             Address of the first register
         n_registers : int
             Number of registers (half the number of bytes)
-        value_type : str | bytes | int
+        value_type : str
             Type to which the value will be cast
                 'int' : signed integer
                 'uint' : unsigned integer
                 'float' : float or double
                 'string' : string
                 'array' : Bytes array
-        value : any
-            The value to write, can be any of the following : str, int, float, str, bytearray
+            Each type will be adapted based on the number of bytes (_bytes parameter)
         byte_order : str
-            Byte order, 'big' means the high bytes will come first, 'little' means the low bytes will come first
-            Byte order inside a register (2 bytes) is always big as per Modbus specification (4.2 Data Encoding)
+            Byte order, 'big' means the high bytes will come first, 'little' means the low bytes
+            will come first
+            Byte order inside a register (2 bytes) is always big as per
+            Modbus specification (4.2 Data Encoding)
         encoding : str
-            String encoding (if used)
-        padding : int
-            Padding in case the value (str / bytes) is not long enough
+            String encoding (if used). UTF-8 by default
+        padding : int | None
+            String padding, None to return the raw string
         Returns
         -------
         data : any
         """
+        # Read N registers
+        registers = await self.aread_holding_registers(
+            start_address=address, number_of_registers=n_registers
+        )
+
+        return self._parse_multi_register_value(
+            n_registers=n_registers,
+            registers=registers,
+            value_type=value_type,
+            byte_order=byte_order,
+            word_order=word_order,
+            encoding=encoding,
+            padding=padding,
+        )
+
+    def _make_multi_register_value(
+        self,
+        n_registers: int,
+        value_type: str,
+        value: str | bytes | int | float,
+        *,
+        byte_order: str = Endian.BIG.value,
+        word_order: str = Endian.BIG.value,
+        encoding: str = "utf-8",
+        padding: int = 0,
+    ) -> list[int]:
         _type = TypeCast(value_type)
         n_bytes = n_registers * 2
         if _type.is_number():
@@ -653,7 +1854,7 @@ class Modbus(Protocol):
         _byte_order = Endian(byte_order)
 
         array = b""
-        if _type == TypeCast.INT or _type == TypeCast.UINT or _type == TypeCast.FLOAT:
+        if _type in [TypeCast.INT, TypeCast.UINT, TypeCast.FLOAT]:
             # Make one big array using word_order endian
             array = struct.pack(
                 endian_symbol[_word_order] + struct_format(_type, n_bytes), value
@@ -693,8 +1894,121 @@ class Modbus(Protocol):
             ]
             for i in range(len(array) // 2)
         ]
+
+        return registers
+
+    def write_multi_register_value(
+        self,
+        address: int,
+        n_registers: int,
+        value_type: str,
+        value: str | bytes | int | float,
+        *,
+        byte_order: str = Endian.BIG.value,
+        word_order: str = Endian.BIG.value,
+        encoding: str = "utf-8",
+        padding: int = 0,
+    ) -> None:
+        """
+        Write an integer, a float, or a string over multiple registers
+
+        Parameters
+        ----------
+        address : int
+            Address of the first register
+        n_registers : int
+            Number of registers (half the number of bytes)
+        value_type : str | bytes | int
+            Type to which the value will be cast
+                'int' : signed integer
+                'uint' : unsigned integer
+                'float' : float or double
+                'string' : string
+                'array' : Bytes array
+        value : any
+            The value to write, can be any of the following : str, int, float, str, bytearray
+        byte_order : str
+            Byte order, 'big' means the high bytes will come first, 'little' means the low
+            bytes will come first
+            Byte order inside a register (2 bytes) is always big as per
+            Modbus specification (4.2 Data Encoding)
+        encoding : str
+            String encoding (if used)
+        padding : int
+            Padding in case the value (str / bytes) is not long enough
+        Returns
+        -------
+        data : any
+        """
+
+        registers = self._make_multi_register_value(
+            n_registers=n_registers,
+            value_type=value_type,
+            value=value,
+            byte_order=byte_order,
+            word_order=word_order,
+            encoding=encoding,
+            padding=padding,
+        )
+
         self.write_multiple_registers(start_address=address, values=registers)
 
+    async def awrite_multi_register_value(
+        self,
+        address: int,
+        n_registers: int,
+        value_type: str,
+        value: str | bytes | int | float,
+        *,
+        byte_order: str = Endian.BIG.value,
+        word_order: str = Endian.BIG.value,
+        encoding: str = "utf-8",
+        padding: int = 0,
+    ) -> None:
+        """
+        Asynchronously write an integer, a float, or a string over multiple registers
+
+        Parameters
+        ----------
+        address : int
+            Address of the first register
+        n_registers : int
+            Number of registers (half the number of bytes)
+        value_type : str | bytes | int
+            Type to which the value will be cast
+                'int' : signed integer
+                'uint' : unsigned integer
+                'float' : float or double
+                'string' : string
+                'array' : Bytes array
+        value : any
+            The value to write, can be any of the following : str, int, float, str, bytearray
+        byte_order : str
+            Byte order, 'big' means the high bytes will come first, 'little' means the low
+            bytes will come first
+            Byte order inside a register (2 bytes) is always big as per
+            Modbus specification (4.2 Data Encoding)
+        encoding : str
+            String encoding (if used)
+        padding : int
+            Padding in case the value (str / bytes) is not long enough
+        Returns
+        -------
+        data : any
+        """
+
+        registers = self._make_multi_register_value(
+            n_registers=n_registers,
+            value_type=value_type,
+            value=value,
+            byte_order=byte_order,
+            word_order=word_order,
+            encoding=encoding,
+            padding=padding,
+        )
+
+        await self.awrite_multiple_registers(start_address=address, values=registers)
+
     # Read Input Registers - 0x04
     def read_input_registers(
         self, start_address: int, number_of_registers: int
@@ -713,72 +2027,67 @@ class Modbus(Protocol):
         registers : list
             List of integers
         """
-        # Same implementation as read_holding_registers
-        EXCEPTIONS = {
-            1: "Function code not supported",
-            2: "Invalid Start or end addresses",
-            3: "Invalid quantity of registers",
-            4: "Couldn't read registers",
-        }
+        payload = ReadInputRegistersSDU(
+            start_address=start_address,
+            number_of_registers=number_of_registers,
+        )
 
-        MAX_NUMBER_OF_REGISTERS = (AVAILABLE_PDU_SIZE - 2) // 2
+        output = cast(ReadInputRegistersSDU.Response, self.query(payload))
 
-        assert (
-            1 <= number_of_registers <= MAX_NUMBER_OF_REGISTERS
-        ), f"Invalid number of registers : {number_of_registers}"
-        query = struct.pack(
-            ENDIAN + "BHH",
-            FunctionCode.READ_INPUT_REGISTERS.value,
-            self._dm_to_pdu_address(start_address),
-            number_of_registers,
-        )
-        response = self._parse_pdu(
-            self._adapter.query(self._make_pdu(self._make_pdu(query)))
-        )
-        self._raise_if_error(response, exception_codes=EXCEPTIONS)
-        _, _, registers_data = struct.unpack(
-            ENDIAN + f"BB{number_of_registers * 2}", response
-        )
-        registers = list(
-            struct.unpack(ENDIAN + "2s" * number_of_registers, registers_data)
+        return output.registers
+
+    async def aread_input_registers(
+        self, start_address: int, number_of_registers: int
+    ) -> list[int]:
+        """
+        Asynchronously read a defined number of input registers starting at a set address
+
+        Parameters
+        ----------
+        start_address : int
+        number_of_registers : int
+            1 to 125
+
+        Returns
+        -------
+        registers : list
+            List of integers
+        """
+        payload = ReadInputRegistersSDU(
+            start_address=start_address,
+            number_of_registers=number_of_registers,
         )
-        return registers
+
+        output = cast(ReadInputRegistersSDU.Response, await self.aquery(payload))
+
+        return output.registers
 
     # Write Single coil - 0x05
-    def write_single_coil(self, address: int, enabled: bool) -> None:
+    def write_single_coil(self, address: int, status: bool) -> None:
         """
         Write a single output to either ON or OFF
 
         Parameters
         ----------
         address : int
-        enabled : bool
+        status : bool
         """
-        ON_VALUE = 0xFF00
-        OFF_VALUE = 0x0000
-        EXCEPTIONS = {
-            1: "Function code not supported",
-            2: "Invalid address",
-            3: "Invalid value",
-            4: "Couldn't set coil output",
-        }
-        assert MIN_ADDRESS <= address <= MAX_ADDRESS, f"Invalid address : {address}"
+        payload = WriteSingleCoilSDU(address=address, status=status)
 
-        query = struct.pack(
-            ENDIAN + "BHH",
-            FunctionCode.WRITE_SINGLE_COIL.value,
-            self._dm_to_pdu_address(address),
-            ON_VALUE if enabled else OFF_VALUE,
-        )
-        response = self._parse_pdu(
-            self._adapter.query(
-                self._make_pdu(query), stop_conditions=Length(self._length(len(query)))
-            )
-        )
-        self._raise_if_error(response, EXCEPTIONS)
-        assert (
-            query == response
-        ), f"Write single coil response should match query {query!r} != {response!r}"
+        self.query(payload)
+
+    async def awrite_single_coil(self, address: int, status: bool) -> None:
+        """
+        Asynchronously write a single output to either ON or OFF
+
+        Parameters
+        ----------
+        address : int
+        status : bool
+        """
+        payload = WriteSingleCoilSDU(address=address, status=status)
+
+        await self.aquery(payload)
 
     # Write Single Register - 0x06
     def write_single_register(self, address: int, value: int) -> None:
@@ -791,30 +2100,29 @@ class Modbus(Protocol):
         value : int
             value between 0x0000 and 0xFFFF
         """
-        EXCEPTIONS = {
-            1: "Function code not supported",
-            2: "Invalid address",
-            3: "Invalid register value",
-            4: "Couldn't write register",
-        }
+        payload = WriteSingleRegisterSDU(
+            address=address,
+            value=value,
+        )
 
-        assert MIN_ADDRESS <= address <= MAX_ADDRESS, f"Invalid address : {address}"
+        self.query(payload)
 
-        query = struct.pack(
-            ENDIAN + "BHH",
-            FunctionCode.WRITE_SINGLE_REGISTER.value,
-            self._dm_to_pdu_address(address),
-            value,
-        )
-        response = self._parse_pdu(
-            self._adapter.query(
-                self._make_pdu(query), stop_conditions=Length(self._length(len(query)))
-            )
+    async def awrite_single_register(self, address: int, value: int) -> None:
+        """
+        Asynchronously write a single register
+
+        Parameters
+        ----------
+        address : int
+        value : int
+            value between 0x0000 and 0xFFFF
+        """
+        payload = WriteSingleRegisterSDU(
+            address=address,
+            value=value,
         )
-        self._raise_if_error(response, EXCEPTIONS)
-        assert (
-            query == response
-        ), f"Response ({response!r}) should match query ({query!r})"
+
+        await self.aquery(payload)
 
     def read_single_register(self, address: int) -> int:
         """
@@ -831,7 +2139,7 @@ class Modbus(Protocol):
         return self.read_holding_registers(address, 1)[0]
 
     # Read Exception Status - 0x07
-    def read_exception_status(self) -> int:  # TODO : Check the return type
+    def read_exception_status(self) -> int:
         """
         Read exeption status
 
@@ -839,75 +2147,56 @@ class Modbus(Protocol):
         -------
         exceptions : int
         """
-        EXCEPTIONS = {
-            1: "Function code not supported",
-            4: "Couldn't read exception status",
-        }
-        if self._modbus_type == ModbusType.TCP:
-            raise RuntimeError("read_exception_status cannot be used with Modbus TCP")
-        query = struct.pack(ENDIAN + "B", FunctionCode.READ_EXCEPTION_STATUS.value)
-        response = self._parse_pdu(self._adapter.query(self._make_pdu(query)))
-        self._raise_if_error(response, EXCEPTIONS)
-        _, exception_status = cast(
-            tuple[int, int], struct.unpack(ENDIAN + "BB", response)
-        )  # TODO : Check this
-        return exception_status
+        payload = ReadExceptionStatusSDU()
+
+        output = cast(ReadExceptionStatusSDU.Response, self.query(payload))
+
+        return output.status
+
+    async def aread_exception_status(self) -> int:
+        """
+        Asynchronously read exeption status
+
+        Returns
+        -------
+        exceptions : int
+        """
+        payload = ReadExceptionStatusSDU()
+
+        output = cast(ReadExceptionStatusSDU.Response, await self.aquery(payload))
+
+        return output.status
 
     # Diagnostics - 0x08
-    # One function for each to simplify parameters and returns
-    def _diagnostics(
-        self,
-        code: DiagnosticsCode,
-        subfunction_data: bytes,
-        return_subfunction_bytes: int,
-        check_response: bool = True,
-    ) -> bytes:
+    def diagnostics_return_query_data(self, data: int = 0x1234) -> bool:
         """
-        Diagnostics wrapper function
+        Run "Return Query Data" diagnostic
+
+        A query is sent and should be return identical
 
         Parameters
         ----------
-        code : DiagnosticsCode
-        check_response : bool
-            Check response function code and subfunction code for equality with query
-            True by default
+        data : int
+            data to send (16 bits integer)
 
         Returns
         -------
-        response
+        success : bool
         """
-
-        EXCEPTIONS = {
-            1: "Unsuported function code or sub-function code",
-            3: "Invalid data value",
-            4: "Diagnostic error",
-        }
-
-        query = (
-            struct.pack(ENDIAN + "BH", FunctionCode.DIAGNOSTICS.value, code)
-            + subfunction_data
+        subfunction_data = struct.pack(ENDIAN + "H", data)
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_QUERY_DATA,
+            subfunction_data=subfunction_data,
+            return_subfunction_bytes=2,
         )
-        response = self._parse_pdu(self._adapter.query(self._make_pdu(query)))
 
-        self._raise_if_error(response, EXCEPTIONS)
+        output = cast(DiagnosticsSDU.Response, self.query(payload))
 
-        returned_function, returned_subfunction_integer, subfunction_returned_data = (
-            cast(
-                tuple[int, int, bytes],
-                struct.unpack(ENDIAN + f"BH{return_subfunction_bytes}s", response),
-            )
-        )
-        if check_response:
-            returned_subfunction = DiagnosticsCode(returned_subfunction_integer)
-            assert (
-                returned_function == FunctionCode.DIAGNOSTICS.value
-            ), f"Invalid returned function code : {returned_function}"
-            assert returned_subfunction == code
-        return subfunction_returned_data
+        return output.data == subfunction_data
 
-    def diagnostics_return_query_data(self, data: int = 0x1234) -> bool:
+    async def adiagnostics_return_query_data(self, data: int = 0x1234) -> bool:
         """
-        Run "Return Query Data" diagnostic
+        Asynchronously run "Return Query Data" diagnostic
 
         A query is sent and should be return identical
 
@@ -921,13 +2210,15 @@ class Modbus(Protocol):
         success : bool
         """
         subfunction_data = struct.pack(ENDIAN + "H", data)
-        try:
-            response = self._diagnostics(
-                DiagnosticsCode.RETURN_QUERY_DATA, subfunction_data, 2
-            )
-            return response == subfunction_data
-        except AssertionError:
-            return False
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_QUERY_DATA,
+            subfunction_data=subfunction_data,
+            return_subfunction_bytes=2,
+        )
+
+        output = cast(DiagnosticsSDU.Response, await self.aquery(payload))
+
+        return output.data == subfunction_data
 
     # TODO : Check how this function interracts with Listen Only mode
     def diagnostics_restart_communications_option(
@@ -944,41 +2235,121 @@ class Modbus(Protocol):
         subfunction_data = struct.pack(
             ENDIAN + "H", 0xFF00 if clear_communications_event_log else 0x0000
         )
-        self._diagnostics(
-            DiagnosticsCode.RESTART_COMMUNICATIONS_OPTION, subfunction_data, 2
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RESTART_COMMUNICATIONS_OPTION,
+            subfunction_data=subfunction_data,
+            return_subfunction_bytes=2,
+        )
+
+        self.query(payload)
+
+    async def adiagnostics_restart_communications_option(
+        self, clear_communications_event_log: bool = False
+    ) -> None:
+        """
+        Asynchronously initialize and restart serial line port.
+        Brings the device out of Listen Only Mode
+
+        Parameters
+        ----------
+        clear_communications_event_log : bool
+            False by default
+        """
+        subfunction_data = struct.pack(
+            ENDIAN + "H", 0xFF00 if clear_communications_event_log else 0x0000
+        )
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RESTART_COMMUNICATIONS_OPTION,
+            subfunction_data=subfunction_data,
+            return_subfunction_bytes=2,
         )
 
+        await self.aquery(payload)
+
     def diagnostics_return_diagnostic_register(self) -> int:
         """
         Return 16 bit diagnostic register
 
-        Returns
-        -------
-        register : int
+        Returns
+        -------
+        register : int
+        """
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_DIAGNOSTIC_REGISTER,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=2,
+        )
+
+        output = cast(DiagnosticsSDU.Response, self.query(payload))
+
+        return int(struct.unpack(ENDIAN + "H", output.data)[0])
+
+    async def adiagnostics_return_diagnostic_register(self) -> int:
+        """
+        Asynchronously return 16 bit diagnostic register
+
+        Returns
+        -------
+        register : int
+        """
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_DIAGNOSTIC_REGISTER,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=2,
+        )
+
+        output = cast(DiagnosticsSDU.Response, await self.aquery(payload))
+
+        return int(struct.unpack(ENDIAN + "H", output.data)[0])
+
+    def diagnostics_change_ascii_input_delimiter(self, char: bytes | str) -> None:
+        """
+        Change the ASCII input delimiter to specified value
+
+        Parameters
+        ----------
+        char : bytes or str
+            Single character
         """
-        returned_data = self._diagnostics(
-            DiagnosticsCode.RETURN_DIAGNOSTIC_REGISTER, b"\x00\x00", 2
+        if len(char) != 1:
+            raise ValueError(f"Invalid char length : {len(char)}")
+        if isinstance(char, str):
+            char = char.encode("ASCII")
+
+        subfunction_data = struct.pack("cB", char, 0)
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.CHANGE_ASCII_INPUT_DELIMITER,
+            subfunction_data=subfunction_data,
+            return_subfunction_bytes=2,
         )
-        return int(struct.unpack("H", returned_data)[0])
 
-    def diagnostics_change_ascii_input_delimiter(self, char: bytes) -> None:
+        self.query(payload)
+
+    async def adiagnostics_change_ascii_input_delimiter(
+        self, char: bytes | str
+    ) -> None:
         """
-        Change the ASCII input delimiter to specified value
+        Asynchronously change the ASCII input delimiter to specified value
 
         Parameters
         ----------
         char : bytes or str
             Single character
         """
-        assert len(char) == 1, f"Invalid char length : {len(char)}"
+        if len(char) != 1:
+            raise ValueError(f"Invalid char length : {len(char)}")
         if isinstance(char, str):
             char = char.encode("ASCII")
 
         subfunction_data = struct.pack("cB", char, 0)
-        self._diagnostics(
-            DiagnosticsCode.CHANGE_ASCII_INPUT_DELIMITER, subfunction_data, 2
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.CHANGE_ASCII_INPUT_DELIMITER,
+            subfunction_data=subfunction_data,
+            return_subfunction_bytes=2,
         )
 
+        await self.aquery(payload)
+
     def diagnostics_force_listen_only_mode(self) -> None:
         """
         Forces the addressed remote device to its Listen Only Mode for MODBUS communications.
@@ -986,130 +2357,327 @@ class Modbus(Protocol):
         communicating without interruption from the addressed remote device. No response is
         returned.
         When the remote device enters its Listen Only Mode, all active communication controls are
-        turned off. The Ready watchdog timer is allowed to expire, locking the controls off. While the
-        device is in this mode, any MODBUS messages addressed to it or broadcast are monitored,
-        but no actions will be taken and no responses will be sent.
+        turned off. The Ready watchdog timer is allowed to expire, locking the controls off.
+        While the device is in this mode, any MODBUS messages addressed to it or broadcast
+        are monitored, but no actions will be taken and no responses will be sent.
         The only function that will be processed after the mode is entered will be the Restart
         Communications Option function (function code 8, sub-function 1).
         """
-        self._diagnostics(
-            DiagnosticsCode.FORCE_LISTEN_ONLY_MODE, b"\x00\x00", 0, check_response=False
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.FORCE_LISTEN_ONLY_MODE,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=0,
+            check_response=False,
+        )
+
+        self.query(payload)
+
+    async def adiagnostics_force_listen_only_mode(self) -> None:
+        """
+        Asynchronously force the addressed remote device to its Listen Only Mode
+        for MODBUS communications.
+        """
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.FORCE_LISTEN_ONLY_MODE,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=0,
+            check_response=False,
         )
 
+        await self.aquery(payload)
+
     def diagnostics_clear_counters_and_diagnostic_register(self) -> None:
         """
         Clear all counters and the diagnostic register
         """
-        self._diagnostics(
-            DiagnosticsCode.CLEAR_COUNTERS_AND_DIAGNOSTIC_REGISTER, b"\x00\x00", 0
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.CLEAR_COUNTERS_AND_DIAGNOSTIC_REGISTER,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=0,
+        )
+
+        self.query(payload)
+
+    async def adiagnostics_clear_counters_and_diagnostic_register(self) -> None:
+        """
+        Asynchronously clear all counters and the diagnostic register
+        """
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.CLEAR_COUNTERS_AND_DIAGNOSTIC_REGISTER,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=0,
         )
 
+        await self.aquery(payload)
+
     def diagnostics_return_bus_message_count(self) -> int:
         """
-        Return the number of messages that the remote device has detection on the communications system since its last restat, clear counters operation, or power-up
+        Return the number of messages that the remote device has detection on the communications
+        system since its last restat, clear counters operation, or power-up
 
         Returns
         -------
         count : int
         """
-        response = self._diagnostics(
-            DiagnosticsCode.RETURN_BUS_MESSAGE_COUNT, b"\x00\x00", 2
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_BUS_MESSAGE_COUNT,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=2,
+        )
+
+        output = cast(DiagnosticsSDU.Response, self.query(payload))
+
+        return int(struct.unpack(ENDIAN + "H", output.data)[0])
+
+    async def adiagnostics_return_bus_message_count(self) -> int:
+        """
+        Asynchronously return the number of messages that the remote device has detection on the
+        communications system since its last restat, clear counters operation, or power-up
+        """
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_BUS_MESSAGE_COUNT,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=2,
         )
-        count = int(struct.unpack("H", response)[0])
-        return count
+
+        output = cast(DiagnosticsSDU.Response, await self.aquery(payload))
+
+        return int(struct.unpack(ENDIAN + "H", output.data)[0])
 
     def diagnostics_return_bus_communication_error_count(self) -> int:
         """
-        Return the number of messages that the remote device has detection on the communications system since its last restart, clear counters operation, or power-up
+        Return the number of messages that the remote device has detection on the communications
+        system since its last restart, clear counters operation, or power-up
 
         Returns
         -------
         count : int
         """
-        response = self._diagnostics(
-            DiagnosticsCode.RETURN_BUS_COMMUNICATION_ERROR_COUNT, b"\x00\x00", 2
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_BUS_COMMUNICATION_ERROR_COUNT,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=2,
+        )
+
+        output = cast(DiagnosticsSDU.Response, self.query(payload))
+
+        return int(struct.unpack(ENDIAN + "H", output.data)[0])
+
+    async def adiagnostics_return_bus_communication_error_count(self) -> int:
+        """
+        Asynchronously return the number of messages that the remote device has detection on the
+        communications system since its last restart, clear counters operation, or power-up
+        """
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_BUS_COMMUNICATION_ERROR_COUNT,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=2,
         )
-        count = int(struct.unpack("H", response)[0])
-        return count
+
+        output = cast(DiagnosticsSDU.Response, await self.aquery(payload))
+
+        return int(struct.unpack(ENDIAN + "H", output.data)[0])
 
     def diagnostics_return_bus_exception_error_count(self) -> int:
         """
-        Return the number of Modbus exceptions responses returned by the remote device since its last restart, clear counters operation, or power-up
+        Return the number of Modbus exceptions responses returned by the remote device since
+        its last restart, clear counters operation, or power-up
 
         Returns
         -------
         count : int
         """
-        response = self._diagnostics(
-            DiagnosticsCode.RETURN_BUS_EXCEPTION_ERROR_COUNT, b"\x00\x00", 2
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_BUS_EXCEPTION_ERROR_COUNT,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=2,
+        )
+
+        output = cast(DiagnosticsSDU.Response, self.query(payload))
+
+        return int(struct.unpack(ENDIAN + "H", output.data)[0])
+
+    async def adiagnostics_return_bus_exception_error_count(self) -> int:
+        """
+        Asynchronously return the number of Modbus exceptions responses returned by the remote
+        device since its last restart, clear counters operation, or power-up
+        """
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_BUS_EXCEPTION_ERROR_COUNT,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=2,
         )
-        count = int(struct.unpack("H", response)[0])
-        return count
+
+        output = cast(DiagnosticsSDU.Response, await self.aquery(payload))
+
+        return int(struct.unpack(ENDIAN + "H", output.data)[0])
 
     def diagnostics_return_server_no_response_count(self) -> int:
         """
-        Return the number of messages addressed to the remote device for which it has returned no response since its last restart, clear counters operation, or power-up
+        Return the number of messages addressed to the remote device for which it has returned
+        no response since its last restart, clear counters operation, or power-up
 
         Returns
         -------
         count : int
         """
-        response = self._diagnostics(
-            DiagnosticsCode.RETURN_SERVER_NO_RESPONSE_COUNT, b"\x00\x00", 2
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_SERVER_NO_RESPONSE_COUNT,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=2,
+        )
+
+        output = cast(DiagnosticsSDU.Response, self.query(payload))
+
+        return int(struct.unpack(ENDIAN + "H", output.data)[0])
+
+    async def adiagnostics_return_server_no_response_count(self) -> int:
+        """
+        Asynchronously return the number of messages addressed to the remote device for which it
+        has returned no response since its last restart, clear counters operation, or power-up
+        """
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_SERVER_NO_RESPONSE_COUNT,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=2,
         )
-        count = int(struct.unpack("H", response)[0])
-        return count
+
+        output = cast(DiagnosticsSDU.Response, await self.aquery(payload))
+
+        return int(struct.unpack(ENDIAN + "H", output.data)[0])
 
     def diagnostics_return_server_nak_count(self) -> int:
         """
-        Return the number of messages addressed to the remote device for which it returned a negative acnowledge (NAK) exception response since its last restart, clear counters operation, or power-up
+        Return the number of messages addressed to the remote device for which it returned
+        a negative acnowledge (NAK) exception response since its last restart, clear counters
+        operation, or power-up
 
         Returns
         -------
         count : int
         """
-        response = self._diagnostics(
-            DiagnosticsCode.RETURN_SERVER_NAK_COUNT, b"\x00\x00", 2
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_SERVER_NAK_COUNT,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=2,
+        )
+
+        output = cast(DiagnosticsSDU.Response, self.query(payload))
+
+        return int(struct.unpack(ENDIAN + "H", output.data)[0])
+
+    async def adiagnostics_return_server_nak_count(self) -> int:
+        """
+        Asynchronously return the number of messages addressed to the remote device for which it
+        returned a negative acnowledge (NAK) exception response since its last restart,
+        clear counters operation, or power-up
+        """
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_SERVER_NAK_COUNT,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=2,
         )
-        count = int(struct.unpack("H", response)[0])
-        return count
+
+        output = cast(DiagnosticsSDU.Response, await self.aquery(payload))
+
+        return int(struct.unpack(ENDIAN + "H", output.data)[0])
 
     def diagnostics_return_server_busy_count(self) -> int:
         """
-        Return the number of messages addressed to the remote device for which it returned a server device busy exception response since its last restart, clear counters operation, or power-up
+        Return the number of messages addressed to the remote device for which it returned a
+        server device busy exception response since its last restart, clear counters operation,
+        or power-up
 
         Returns
         -------
         count : int
         """
-        response = self._diagnostics(
-            DiagnosticsCode.RETURN_SERVER_BUSY_COUNT, b"\x00\x00", 2
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_SERVER_BUSY_COUNT,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=2,
+        )
+
+        output = cast(DiagnosticsSDU.Response, self.query(payload))
+
+        return int(struct.unpack(ENDIAN + "H", output.data)[0])
+
+    async def adiagnostics_return_server_busy_count(self) -> int:
+        """
+        Asynchronously return the number of messages addressed to the remote device for which it
+        returned a server device busy exception response since its last restart, clear counters
+        operation, or power-up
+        """
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_SERVER_BUSY_COUNT,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=2,
         )
-        count = int(struct.unpack("H", response)[0])
-        return count
+
+        output = cast(DiagnosticsSDU.Response, await self.aquery(payload))
+
+        return int(struct.unpack(ENDIAN + "H", output.data)[0])
 
     def diagnostics_return_bus_character_overrun_count(self) -> int:
         """
-        Return the number of messages addressed to the remote device that it could not handle due to a character overrun condition since its last restart, clear counters operation, or power-up
+        Return the number of messages addressed to the remote device that it could not handle
+        due to a character overrun condition since its last restart, clear counters operation,
+        or power-up
 
         Returns
         -------
         count : int
         """
-        response = self._diagnostics(
-            DiagnosticsCode.RETURN_BUS_CHARACTER_OVERRUN_COUNT, b"\x00\x00", 2
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_BUS_CHARACTER_OVERRUN_COUNT,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=2,
+        )
+
+        output = cast(DiagnosticsSDU.Response, self.query(payload))
+
+        return int(struct.unpack(ENDIAN + "H", output.data)[0])
+
+    async def adiagnostics_return_bus_character_overrun_count(self) -> int:
+        """
+        Asynchronously return the number of messages addressed to the remote device that it could
+        not handle due to a character overrun condition since its last restart, clear counters
+        operation, or power-up
+        """
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.RETURN_BUS_CHARACTER_OVERRUN_COUNT,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=2,
         )
-        count = int(struct.unpack("H", response)[0])
-        return count
+
+        output = cast(DiagnosticsSDU.Response, await self.aquery(payload))
+
+        return int(struct.unpack(ENDIAN + "H", output.data)[0])
 
     def diagnostics_clear_overrun_counter_and_flag(self) -> None:
         """
         Clear the overrun error counter and reset the error flag
         """
-        self._diagnostics(
-            DiagnosticsCode.CLEAR_OVERRUN_COUNTER_AND_FLAG, b"\x00\x00", 0
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.CLEAR_OVERRUN_COUNTER_AND_FLAG,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=0,
+        )
+
+        self.query(payload)
+
+    async def adiagnostics_clear_overrun_counter_and_flag(self) -> None:
+        """
+        Asynchronously clear the overrun error counter and reset the error flag
+        """
+        payload = DiagnosticsSDU(
+            code=DiagnosticsCode.CLEAR_OVERRUN_COUNTER_AND_FLAG,
+            subfunction_data=b"\x00\x00",
+            return_subfunction_bytes=0,
         )
 
+        await self.aquery(payload)
+
     # Get Comm Event Counter - 0x0B
     def get_comm_event_counter(self) -> tuple[int, int]:
         """
@@ -1120,20 +2688,28 @@ class Modbus(Protocol):
         status : int
         event_count : int
         """
-        EXCEPTIONS = {
-            1: "Function code not supported",
-            4: "Couldn't get comm event counter",
-        }
-        query = struct.pack(ENDIAN + "B", FunctionCode.GET_COMM_EVENT_COUNTER.value)
-        response = self._parse_pdu(self._adapter.query(self._make_pdu(query)))
-        self._raise_if_error(response, EXCEPTIONS)
-        _, status, event_count = struct.unpack(ENDIAN + "BHH", response)
-        return status, event_count
+        payload = GetCommEventCounterSDU()
+
+        output = cast(GetCommEventCounterSDU.Response, self.query(payload))
+
+        return output.status, output.event_count
+
+    async def aget_comm_event_counter(self) -> tuple[int, int]:
+        """
+        Asynchronously retrieve status word and event count from the remote device's
+        communication event counter
+        """
+        payload = GetCommEventCounterSDU()
+
+        output = cast(GetCommEventCounterSDU.Response, await self.aquery(payload))
+
+        return output.status, output.event_count
 
     # Get Comm Event Log - 0x0C
     def get_comm_event_log(self) -> tuple[int, int, int, bytes]:
         """
-        Retrieve status word, event count, message count and a field of event bytes from the remote device
+        Retrieve status word, event count, message count and a field of event bytes from
+        the remote device
 
         Status word and event count are identical to those returned by get_comm_event_counter()
 
@@ -1142,26 +2718,29 @@ class Modbus(Protocol):
         status : int
         event_count : int
         message_count : int
-            Number of messages processed since its last restart, clear counters operation, or power-up
+            Number of messages processed since its last restart, clear counters operation,
+            or power-up
             Identical to diagnostics_return_bus_message_count()
         events : bytes
-            0-64 bytes, each corresponding to the status of one Modbus send or receive operation for
-            the remote device. Byte 0 is the most recent event
+            0-64 bytes, each corresponding to the status of one Modbus send or receive
+            operation for the remote device. Byte 0 is the most recent event
         """
+        payload = GetCommEventLogSDU()
 
-        EXCEPTIONS = {
-            1: "Function code not supported",
-            4: "Couldn't get comm event log",
-        }
-        query = struct.pack(ENDIAN + "B", FunctionCode.GET_COMM_EVENT_LOG.value)
-        response = self._parse_pdu(self._adapter.query(self._make_pdu(query)))
-        self._raise_if_error(response, EXCEPTIONS)
-        _, byte_count, status, event_count, message_count = struct.unpack(
-            "BBHHH", response
-        )
-        events = struct.unpack(ENDIAN + f"8x{byte_count - 6}B", response)[0]
+        output = cast(GetCommEventLogSDU.Response, self.query(payload))
+
+        return output.status, output.event_count, output.message_count, output.events
 
-        return status, event_count, message_count, events
+    async def aget_comm_event_log(self) -> tuple[int, int, int, bytes]:
+        """
+        Asynchronously retrieve status word, event count, message count and a field of event bytes
+        from the remote device
+        """
+        payload = GetCommEventLogSDU()
+
+        output = cast(GetCommEventLogSDU.Response, await self.aquery(payload))
+
+        return output.status, output.event_count, output.message_count, output.events
 
     # Write Multiple Coils - 0x0F
     def write_multiple_coils(self, start_address: int, values: list[bool]) -> None:
@@ -1174,43 +2753,25 @@ class Modbus(Protocol):
         value : list
             Bool values
         """
-        # TODO : Check behavior against page 29 of the modbus spec (endianness of values)
-        EXCEPTIONS = {
-            1: "Function code not supported",
-            2: "Invalid start and/or end addresses",
-            3: "Invalid number of outputs and/or byte count",
-            4: "Couldn't write outputs",
-        }
+        payload = WriteMultipleCoilsSDU(
+            start_address=start_address,
+            values=values,
+        )
 
-        number_of_coils = len(values)
-        assert (
-            1 <= number_of_coils <= MAX_DISCRETE_INPUTS
-        ), f"Invalid number of coils : {number_of_coils}"
-        assert (
-            1 <= start_address <= MAX_ADDRESS - number_of_coils + 1
-        ), f"Invalid start address : {start_address}"
-        byte_count = ceil(number_of_coils / 8)
+        self.query(payload)
 
-        query = struct.pack(
-            ENDIAN + f"BHHB{byte_count}s",
-            FunctionCode.WRITE_MULTIPLE_COILS.value,
-            self._dm_to_pdu_address(start_address),
-            number_of_coils,
-            byte_count,
-            bool_list_to_bytes(values),
-        )
-        response = self._parse_pdu(
-            self._adapter.query(
-                self._make_pdu(query), stop_conditions=Length(self._length(5))
-            )
+    async def awrite_multiple_coils(
+        self, start_address: int, values: list[bool]
+    ) -> None:
+        """
+        Asynchronously write multiple coil values
+        """
+        payload = WriteMultipleCoilsSDU(
+            start_address=start_address,
+            values=values,
         )
-        self._raise_if_error(response, EXCEPTIONS)
 
-        _, _, coils_written = struct.unpack(ENDIAN + "BHH", response)
-        if coils_written != number_of_coils:
-            raise RuntimeError(
-                f"Number of coils written ({coils_written}) doesn't match expected value : {number_of_coils}"
-            )
+        await self.aquery(payload)
 
     # Write Multiple Registers - 0x10
     def write_multiple_registers(self, start_address: int, values: list[int]) -> None:
@@ -1224,52 +2785,33 @@ class Modbus(Protocol):
             List of integers
 
         """
-        EXCEPTIONS = {
-            1: "Function code not supported",
-            2: "Invalid start and/or end addresses",
-            3: "Invalid number of outputs and/or byte count",
-            4: "Couldn't write outputs",
-        }
-        byte_count = 2 * len(values)
-
-        # Specs says 123, but it would exceed 255 bytes over TCP. So 121 is safer
-        MAX_NUMBER_OF_REGISTERS = (AVAILABLE_PDU_SIZE - 6) // 2
+        payload = WriteMultipleRegistersSDU(
+            start_address=start_address,
+            values=values,
+        )
 
-        assert len(values) > 0, "Empty register list"
-        assert (
-            len(values) <= MAX_NUMBER_OF_REGISTERS
-        ), f"Cannot set more than {MAX_NUMBER_OF_REGISTERS} registers at a time"
-        assert (
-            MIN_ADDRESS <= start_address <= MAX_ADDRESS - len(values) + 1
-        ), f"Invalid address : {start_address}"
+        self.query(payload)
 
-        query = struct.pack(
-            ENDIAN + f"BHHB{byte_count // 2}H",
-            FunctionCode.WRITE_MULTIPLE_REGISTERS.value,
-            self._dm_to_pdu_address(start_address),
-            byte_count // 2,
-            byte_count,
-            *values,
-        )
-        response = self._parse_pdu(
-            self._adapter.query(
-                self._make_pdu(query), stop_conditions=Length(self._length(5))
-            )
+    async def awrite_multiple_registers(
+        self, start_address: int, values: list[int]
+    ) -> None:
+        """
+        Asynchronously write multiple registers
+        """
+        payload = WriteMultipleRegistersSDU(
+            start_address=start_address,
+            values=values,
         )
-        self._raise_if_error(response, EXCEPTIONS)
 
-        _, _, coils_written = struct.unpack(ENDIAN + "BHH", response)
-        if coils_written != byte_count // 2:
-            raise RuntimeError(
-                f"Number of coils written ({coils_written}) doesn't match expected value : {byte_count // 2}"
-            )
+        await self.aquery(payload)
 
     # Report Server ID - 0x11
     def report_server_id(
         self, server_id_length: int, additional_data_length: int
     ) -> tuple[bytes, bool, bytes]:
         """
-        Read description of the type, current status and other information specific to a remote device
+        Read description of the type, current status and other information specific to
+        a remote device
 
         Parameters
         ----------
@@ -1283,21 +2825,38 @@ class Modbus(Protocol):
         run_indicator_status : bool
         additional_data : bytes
         """
-        EXCEPTIONS = {1: "Function code not supported", 4: "Couldn't report slave ID"}
-        query = struct.pack(ENDIAN + "B", FunctionCode.REPORT_SERVER_ID.value)
-        response = self._parse_pdu(self._adapter.query(self._make_pdu(query)))
-        self._raise_if_error(response, EXCEPTIONS)
-        server_id, run_indicator_status, additional_data = struct.unpack(
-            ENDIAN + f"{server_id_length}sB{additional_data_length}s", response
+        payload = ReportServerIdSDU(
+            server_id_length=server_id_length,
+            additional_data_length=additional_data_length,
+        )
+
+        output = cast(ReportServerIdSDU.Response, self.query(payload))
+
+        return output.server_id, output.run_indicator_status, output.additional_data
+
+    async def areport_server_id(
+        self, server_id_length: int, additional_data_length: int
+    ) -> tuple[bytes, bool, bytes]:
+        """
+        Asynchronously read description of the type, current status and other information specific
+        to a remote device
+        """
+        payload = ReportServerIdSDU(
+            server_id_length=server_id_length,
+            additional_data_length=additional_data_length,
         )
-        return server_id, run_indicator_status == 0xFF, additional_data
+
+        output = cast(ReportServerIdSDU.Response, await self.aquery(payload))
+
+        return output.server_id, output.run_indicator_status, output.additional_data
 
     # Read File Record - 0x14
     def read_file_record(self, records: list[tuple[int, int, int]]) -> list[bytes]:
         """
         Perform a single or multiple file record read
 
-        Total response length cannot exceed 253 bytes, meaning the number of records and their length is limited.
+        Total response length cannot exceed 253 bytes, meaning the number of records
+        and their length is limited.
 
 
         Query equation : 2 + 7*N <= 253
@@ -1313,116 +2872,62 @@ class Modbus(Protocol):
         records_data : list
             List of bytes
         """
-        SIZE_LIMIT = 253
-        REFERENCE_TYPE = 6
-        EXCEPTIONS = {
-            1: "Function code not supported",
-            2: "Invalid parameters",
-            3: "Invalid byte count",
-            4: "Couldn't read records",
-        }
+        payload = ReadFileRecordSDU(records=records)
 
-        assert isinstance(records, list)
+        output = cast(ReadFileRecordSDU.Response, self.query(payload))
 
-        query_size = 2 + 7 * len(records)
-        response_size = 2 + len(records) + sum(2 * r[2] for r in records)
-        if query_size > SIZE_LIMIT:
-            raise ValueError(f"Number of records is too high : {len(records)}")
-        if response_size > SIZE_LIMIT:
-            raise ValueError(
-                f"Sum of records lenghts is too high : {sum([r[2] for r in records])}"
-            )
+        return output.records_data
 
-        sub_req_buffer = b""
-        for file_number, record_number, record_length in records:
-            sub_req_buffer += struct.pack(
-                ENDIAN + "BHHH",
-                REFERENCE_TYPE,
-                file_number,
-                record_number,
-                record_length,
-            )
+    async def aread_file_record(
+        self, records: list[tuple[int, int, int]]
+    ) -> list[bytes]:
+        """
+        Asynchronously perform a single or multiple file record read
+        """
+        payload = ReadFileRecordSDU(records=records)
 
-        byte_count = len(sub_req_buffer)
+        output = cast(ReadFileRecordSDU.Response, await self.aquery(payload))
 
-        query = struct.pack(
-            ENDIAN + f"BB{byte_count}s",
-            FunctionCode.READ_FILE_RECORD,
-            byte_count,
-            sub_req_buffer,
-        )
-        response = self._parse_pdu(self._adapter.query(self._make_pdu(query)))
-        self._raise_if_error(response, EXCEPTIONS)
-        # Parse the response
-        # start at position 2
-        records_data = []
-        i = 2
-        while True:
-            length = response[i]
-            i += 1
-            # Ignore teh reference type
-            # Read the record data
-            records_data.append(response[i : i + length])
-            i += length
-
-        return records_data
+        return output.records_data
 
     # Write File Record - 0x15
     def write_file_record(self, records: list[tuple[int, int, bytes]]) -> None:
         """
         Perform a single or multiple file record write
 
-        Total query and response length cannot exceed 253 bytes, meaning the number of records and their length is limited.
+        Total query and response length cannot exceed 253 bytes, meaning the number of
+        records and their length is limited.
 
         Query equation : 2 + 7*N + sum(Li*2) <= 253
         Response equation : identical
 
-        File number can be between 0x0001 and 0xFFFF but lots of legacy equipment will not support file number above 0x000A (10)
+        File number can be between 0x0001 and 0xFFFF but lots of legacy equipment will
+        not support file number above 0x000A (10)
 
         Parameters
         ----------
         records : list
             List of tuples : (file_number, record_number, data)
         """
-        REFERENCE_TYPE = 6
-        EXCEPTIONS = {
-            1: "Function code not supported",
-            2: "Invalid parameters",
-            3: "Invalid byte count",
-            4: "Couldn't write records",
-        }
-
-        if isinstance(records, tuple):
-            records = [records]
-        elif not isinstance(records, list):
-            raise TypeError(f"Invalid records type : {records}")
+        payload = WriteFileRecordSDU(records=records)
 
-        sub_req_buffer = b""
+        self.query(payload)
 
-        for file_number, record_number, data in records:
-            sub_req_buffer += struct.pack(
-                ENDIAN + f"BHHH{len(data)}s",
-                REFERENCE_TYPE,
-                file_number,
-                record_number,
-                len(data) // 2,
-                data,
-            )
+    async def awrite_file_record(self, records: list[tuple[int, int, bytes]]) -> None:
+        """
+        Asynchronously perform a single or multiple file record write
+        """
+        payload = WriteFileRecordSDU(records=records)
 
-        query = struct.pack(
-            ENDIAN + f"BB{len(sub_req_buffer)}s",
-            FunctionCode.WRITE_FILE_RECORD,
-            len(sub_req_buffer),
-            sub_req_buffer,
-        )
-        response = self._parse_pdu(self._adapter.query(self._make_pdu(query)))
-        self._raise_if_error(response, EXCEPTIONS)
-        assert response == query
+        await self.aquery(payload)
 
     # Mask Write Register - 0x16
-    def mask_write_register(self, address: int, and_mask: int, or_mask: int) -> None:
+    async def amask_write_register(
+        self, address: int, and_mask: int, or_mask: int
+    ) -> None:
         """
-        This function is used to modify the contents of a holding register using a combination of AND and OR masks applied to the current contents of the register.
+        This function is used to modify the contents of a holding register using a
+        combination of AND and OR masks applied to the current contents of the register.
 
         The algorithm is :
 
@@ -1437,30 +2942,26 @@ class Modbus(Protocol):
         or_mask : int
             0x0000 to 0xFFFF
         """
-        EXCEPTIONS = {
-            1: "Function code not supported",
-            2: "Invalid register address",
-            3: "Invalid AND/OR mask",
-            4: "Couldn't write register",
-        }
-        assert MIN_ADDRESS <= address <= MAX_ADDRESS, f"Invalid address : {address}"
+        payload = MaskWriteRegisterSDU(
+            address=address,
+            and_mask=and_mask,
+            or_mask=or_mask,
+        )
 
-        query = struct.pack(
-            ENDIAN + "BHHH",
-            FunctionCode.MASK_WRITE_REGISTER.value,
-            self._dm_to_pdu_address(address),
-            and_mask,
-            or_mask,
-        )
-        response = self._parse_pdu(
-            self._adapter.query(
-                self._make_pdu(query), stop_conditions=Length(self._length(len(query)))
-            )
+        await self.aquery(payload)
+
+    def mask_write_register(self, address: int, and_mask: int, or_mask: int) -> None:
+        """
+        This function is used to modify the contents of a holding register using a
+        combination of AND and OR masks applied to the current contents of the register.
+        """
+        payload = MaskWriteRegisterSDU(
+            address=address,
+            and_mask=and_mask,
+            or_mask=or_mask,
         )
-        self._raise_if_error(response, EXCEPTIONS)
-        assert (
-            response == query
-        ), f"Response ({response!r}) should match query ({query!r})"
+
+        self.query(payload)
 
     # Read/Write Multiple Registers - 0x17
     def read_write_multiple_registers(
@@ -1468,8 +2969,8 @@ class Modbus(Protocol):
         read_starting_address: int,
         number_of_read_registers: int,
         write_starting_address: int,
-        write_values: list[bytes],
-    ) -> list[bytes]:
+        write_values: list[int],
+    ) -> list[int]:
         """
         Do a write, then a read operation, each on a specific set of registers.
 
@@ -1485,54 +2986,39 @@ class Modbus(Protocol):
         -------
         read_values : list
         """
-        EXCEPTIONS = {
-            1: "Function code not supported",
-            2: "Invalid read/write start/end address",
-            3: "Invalid quantity of read/write and/or byte count",
-            4: "Couldn't read and/or write registers",
-        }
+        payload = ReadWriteMultipleRegistersSDU(
+            read_starting_address=read_starting_address,
+            number_of_read_registers=number_of_read_registers,
+            write_starting_address=write_starting_address,
+            write_values=write_values,
+        )
 
-        MAX_NUMBER_READ_REGISTERS = (AVAILABLE_PDU_SIZE - 2) // 2
-        MAX_NUMBER_WRITE_REGISTERS = (AVAILABLE_PDU_SIZE - 10) // 2
-
-        assert (
-            1 <= number_of_read_registers <= MAX_NUMBER_READ_REGISTERS
-        ), f"Invalid number of read registers : {number_of_read_registers}"
-        assert (
-            MIN_ADDRESS
-            <= read_starting_address
-            <= MAX_ADDRESS - number_of_read_registers + 1
-        ), f"Invalid read start address : {read_starting_address}"
-
-        assert (
-            1 <= len(write_values) <= MAX_NUMBER_WRITE_REGISTERS
-        ), f"Invalid number of write registers  : {len(write_values)}"
-        assert (
-            MIN_ADDRESS <= write_starting_address <= MAX_ADDRESS - len(write_values) + 1
-        ), f"Invalid write start address (writing {len(write_values)} registers) : {write_starting_address}"
-
-        query = struct.pack(
-            ENDIAN + f"BHHHHB{len(write_values)}H",
-            FunctionCode.READ_WRITE_MULTIPLE_REGISTERS.value,
-            read_starting_address,
-            number_of_read_registers,
-            write_starting_address,
-            len(write_values),
-            len(write_values) * 2,
-            *write_values,
-        )
-        response = self._parse_pdu(
-            self._adapter.query(
-                self._make_pdu(query),
-                stop_conditions=Length(self._length(2 + number_of_read_registers * 2)),
-            )
+        output = cast(ReadWriteMultipleRegistersSDU.Response, self.query(payload))
+
+        return output.read_values
+
+    async def aread_write_multiple_registers(
+        self,
+        read_starting_address: int,
+        number_of_read_registers: int,
+        write_starting_address: int,
+        write_values: list[int],
+    ) -> list[int]:
+        """
+        Asynchronously do a write, then a read operation, each on a specific set of registers.
+        """
+        payload = ReadWriteMultipleRegistersSDU(
+            read_starting_address=read_starting_address,
+            number_of_read_registers=number_of_read_registers,
+            write_starting_address=write_starting_address,
+            write_values=write_values,
+        )
+
+        output = cast(
+            ReadWriteMultipleRegistersSDU.Response, await self.aquery(payload)
         )
-        self._raise_if_error(response, EXCEPTIONS)
-        # Parse response
-        output = struct.unpack(ENDIAN + f"BB{number_of_read_registers}H", response)
-        # _, _, read_values
-        read_values = list(output[2:])
-        return read_values
+
+        return output.read_values
 
     # Read FIFO Queue - 0x18
     def read_fifo_queue(self, fifo_address: int) -> list[int]:
@@ -1547,23 +3033,21 @@ class Modbus(Protocol):
         -------
         registers : list
         """
-        EXCEPTIONS = {
-            1: "Function code not supported",
-            2: "Invalid FIFO address",
-            3: "Invalid FIFO count (>31)",
-            4: "Couldn't read FIFO queue",
-        }
-        query = struct.pack(ENDIAN + "BH", FunctionCode.READ_FIFO_QUEUE, fifo_address)
-        response = self._parse_pdu(self._adapter.query(self._make_pdu(query)))
-        self._raise_if_error(response, EXCEPTIONS)
-        byte_count = int(struct.unpack(ENDIAN + "xH", response)[0])
-        register_count = byte_count // 2 - 1
+        payload = ReadFifoQueueSDU(fifo_address=fifo_address)
+
+        output = cast(ReadFifoQueueSDU.Response, self.query(payload))
+
+        return output.values
 
-        values = cast(
-            list[int], struct.unpack(ENDIAN + f"{register_count}H", response[5:])[0]
-        )  # Ignore the FIFO count
+    async def aread_fifo_queue(self, fifo_address: int) -> list[int]:
+        """
+        Asynchronously read the contents of a First-In-First-Out (FIFO) queue of registers
+        """
+        payload = ReadFifoQueueSDU(fifo_address=fifo_address)
 
-        return values
+        output = cast(ReadFifoQueueSDU.Response, await self.aquery(payload))
+
+        return output.values
 
     # Encapsulate Interface Transport - 0x2B
     def encapsulated_interface_transport(
@@ -1573,7 +3057,8 @@ class Modbus(Protocol):
         extra_exceptions: dict[int, str] | None = None,
     ) -> bytes:
         """
-        The MODBUS Encapsulated Interface (MEI) Transport is a mechanism for tunneling service requests and method invocations
+        The MODBUS Encapsulated Interface (MEI) Transport is a mechanism for tunneling
+        service requests and method invocations
 
         Parameters
         ----------
@@ -1584,18 +3069,33 @@ class Modbus(Protocol):
         -------
         returned_mei_data : bytes
         """
-        EXCEPTIONS = {
-            1: "Function code not supported",
-        }
-        if extra_exceptions is not None:
-            EXCEPTIONS.update(extra_exceptions)
-
-        query = struct.pack(
-            ENDIAN + f"BB{len(mei_data)}s",
-            FunctionCode.ENCAPSULATED_INTERFACE_TRANSPORT,
-            mei_type,
-            mei_data,
-        )
-        response = self._parse_pdu(self._adapter.query(self._make_pdu(query)))
-        self._raise_if_error(response, EXCEPTIONS)
-        return response[2:]
+        payload = EncapsulatedInterfaceTransportSDU(
+            mei_type=mei_type,
+            mei_data=mei_data,
+            extra_exceptions=extra_exceptions,
+        )
+
+        output = cast(EncapsulatedInterfaceTransportSDU.Response, self.query(payload))
+
+        return output.data
+
+    async def aencapsulated_interface_transport(
+        self,
+        mei_type: int,
+        mei_data: bytes,
+        extra_exceptions: dict[int, str] | None = None,
+    ) -> bytes:
+        """
+        Asynchronously use the MODBUS Encapsulated Interface (MEI) Transport
+        """
+        payload = EncapsulatedInterfaceTransportSDU(
+            mei_type=mei_type,
+            mei_data=mei_data,
+            extra_exceptions=extra_exceptions,
+        )
+
+        output = cast(
+            EncapsulatedInterfaceTransportSDU.Response, await self.aquery(payload)
+        )
+
+        return output.data