pypck 0.7.24__py3-none-any.whl → 0.8.2__py3-none-any.whl

pypck/connection.py

@@ -5,22 +5,19 @@ from __future__ import annotations
 import asyncio
 import logging
 import time
-from collections import deque
-from collections.abc import Awaitable, Callable, Iterable
+from collections.abc import Callable, Iterable
 from types import TracebackType
 from typing import Any
 
 from pypck import inputs, lcn_defs
 from pypck.helpers import TaskRegistry
 from pypck.lcn_addr import LcnAddr
+from pypck.lcn_defs import LcnEvent
 from pypck.module import AbstractConnection, GroupConnection, ModuleConnection
 from pypck.pck_commands import PckGenerator
 
 _LOGGER = logging.getLogger(__name__)
 
-READ_TIMEOUT = -1
-SOCKET_CLOSED = -2
-
 
 class PchkLicenseError(Exception):
     """Exception which is raised if a license error occurred."""
@@ -29,7 +26,7 @@ class PchkLicenseError(Exception):
         """Initialize instance."""
         if message is None:
             message = (
-                "Maximum number of connections was reached. An "
+                "License Error: Maximum number of connections was reached. An "
                 "additional license key is required."
             )
         super().__init__(message)
@@ -41,182 +38,47 @@ class PchkAuthenticationError(Exception):
     def __init__(self, message: str | None = None):
         """Initialize instance."""
         if message is None:
-            message = "Authentication failed."
+            message = "Authentication failed"
         super().__init__(message)
 
 
-class PchkLcnNotConnectedError(Exception):
-    """Exception which is raised if there is no connection to the LCN bus."""
+class PchkConnectionRefusedError(Exception):
+    """Exception which is raised if connection was refused."""
 
     def __init__(self, message: str | None = None):
         """Initialize instance."""
         if message is None:
-            message = "LCN not connected."
+            message = "Connection refused"
         super().__init__(message)
 
 
-class PchkConnection:
-    """Socket connection to LCN-PCHK server.
-
-    :param    str    host:        Server IP address formatted as
-                                  xxx.xxx.xxx.xxx
-    :param    int    port:        Server port
-
-    :Note:
-
-    :class:`PchkConnection` does only open a port to the
-    PCHK server and allows to send and receive plain text. Use
-    :func:`~PchkConnection.send_command` and
-    :func:`~PchkConnection.process_input` callback to send and receive
-    text messages.
-
-    For login logic or communication with modules use
-    :class:`~PchkConnectionManager`.
-    """
-
-    def __init__(self, host: str, port: int, connection_id: str = "PCHK"):
-        """Construct PchkConnection."""
-        self.task_registry = TaskRegistry()
-        self.host = host
-        self.port = port
-        self.connection_id = connection_id
-        self.reader: asyncio.StreamReader | None = None
-        self.writer: asyncio.StreamWriter | None = None
-        self.buffer: deque[bytes] = deque()
-        self.idle_time = 0.05
-        self.last_bus_activity = time.time()
-        self.event_handler: Callable[[str], Awaitable[None]] = (
-            self.default_event_handler
-        )
-
-    async def async_connect(self) -> None:
-        """Connect to a PCHK server (no authentication or license error check)."""
-        self.reader, self.writer = await asyncio.open_connection(self.host, self.port)
-        address = self.writer.get_extra_info("peername")
-        _LOGGER.debug("%s server connected at %s:%d", self.connection_id, *address)
-
-        # main write loop
-        self.task_registry.create_task(self.write_data_loop())
-
-        # main read loop
-        self.task_registry.create_task(self.read_data_loop())
-
-    def connect(self) -> None:
-        """Create a task to connect to a PCHK server concurrently."""
-        self.task_registry.create_task(self.async_connect())
-
-    async def read_data_loop(self) -> None:
-        """Is called when some data is received."""
-        assert self.reader is not None
-        assert self.writer is not None
-        while not self.writer.is_closing():
-            try:
-                data = await self.reader.readuntil(PckGenerator.TERMINATION.encode())
-                self.last_bus_activity = time.time()
-            except asyncio.IncompleteReadError:
-                _LOGGER.debug("Connection to %s lost", self.connection_id)
-                await self.event_handler("connection-lost")
-                await self.async_close()
-                break
-            except asyncio.CancelledError:
-                break
-
-            try:
-                message = data.decode().split(PckGenerator.TERMINATION)[0]
-            except UnicodeDecodeError as err:
-                _LOGGER.warning(
-                    "PCK decoding error: %s - skipping received PCK message", err
-                )
-                continue
-            await self.process_message(message)
-
-    async def write_data_loop(self) -> None:
-        """Processes queue and writes data."""
-        assert self.writer is not None
-        while not self.writer.is_closing():
-            await asyncio.sleep(self.idle_time)
-            if len(self.buffer) == 0:
-                continue
-            if time.time() - self.last_bus_activity < self.idle_time:
-                continue
-            data = self.buffer.popleft()
-            self.last_bus_activity = time.time()
-
-            _LOGGER.debug(
-                "to %s: %s",
-                self.connection_id,
-                data.decode().rstrip(PckGenerator.TERMINATION),
-            )
-            self.writer.write(data)
-            await self.writer.drain()
-
-    async def send_command(self, pck: bytes | str, **kwargs: Any) -> bool:
-        """Send a PCK command to the PCHK server.
-
-        :param    str    pck:    PCK command
-        """
-        assert self.writer is not None
-        if not self.writer.is_closing():
-            if isinstance(pck, str):
-                data = (pck + PckGenerator.TERMINATION).encode()
-            else:
-                data = pck + PckGenerator.TERMINATION.encode()
-            self.buffer.append(data)
-            return True
-        return False
-
-    async def process_message(self, message: str) -> None:
-        """Is called when a new text message is received from the PCHK server.
-
-        This class should be reimplemented in any subclass which evaluates
-        received messages.
-
-        :param    str    input:    Input text message
-        """
-        _LOGGER.debug("from %s: %s", self.connection_id, message)
+class PchkConnectionFailedError(Exception):
+    """Exception which is raised if connection was refused."""
 
-    async def async_close(self) -> None:
-        """Close the active connection."""
-        await self.task_registry.cancel_all_tasks()
-        if self.writer:
-            self.writer.close()
-            await self.writer.wait_closed()
-
-    def set_event_handler(self, coro: Callable[[str], Awaitable[None]]) -> None:
-        """Set the event handler for specific LCN events."""
-        if coro is None:
-            self.event_handler = self.default_event_handler
-        else:
-            self.event_handler = coro
+    def __init__(self, message: str | None = None):
+        """Initialize instance."""
+        if message is None:
+            message = "Connection failed"
+        super().__init__(message)
 
-    async def default_event_handler(self, event: str) -> None:
-        """Handle events for specific LCN events."""
-
-    async def wait_closed(self) -> None:
-        """Wait until connection to PCHK server is closed."""
-        if self.writer is not None:
-            await self.writer.wait_closed()
 
+class PchkLcnNotConnectedError(Exception):
+    """Exception which is raised if there is no connection to the LCN bus."""
 
-class PchkConnectionManager(PchkConnection):
-    """Connection to LCN-PCHK.
+    def __init__(self, message: str | None = None):
+        """Initialize instance."""
+        if message is None:
+            message = "LCN not connected."
+        super().__init__(message)
 
-    Has the following tasks:
-    - Initiates login procedure.
-    - Ping PCHK.
-    - Parse incoming commands and create input objects.
-    - Calls input object's process method.
-    - Updates seg_id of ModuleConnections if segment scan finishes.
 
-    :param    str    host:        Server IP address formatted as
-                                  xxx.xxx.xxx.xxx
-    :param    int    port:        Server port
-    :param    str    username:    usernam for login.
-    :param    str    password:    Password for login.
+class PchkConnectionManager:
+    """Connection to LCN-PCHK."""
 
-    An example how to setup a proper connection to PCHK including login and
-    (automatic) segment coupler scan is shown below.
-    """
+    last_ping: float
+    ping_timeout_handle: asyncio.TimerHandle | None
+    authentication_completed_future: asyncio.Future[bool]
+    license_error_future: asyncio.Future[bool]
 
     def __init__(
         self,
@@ -226,23 +88,32 @@ class PchkConnectionManager(PchkConnection):
         password: str,
         settings: dict[str, Any] | None = None,
         connection_id: str = "PCHK",
-    ):
+    ) -> None:
         """Construct PchkConnectionManager."""
-        super().__init__(host, port, connection_id)
+        self.task_registry = TaskRegistry()
+        self.host = host
+        self.port = port
+        self.connection_id = connection_id
+
+        self.reader: asyncio.StreamReader | None = None
+        self.writer: asyncio.StreamWriter | None = None
+        self.buffer: asyncio.Queue[bytes] = asyncio.Queue()
+        self.last_bus_activity = time.time()
 
         self.username = username
         self.password = password
 
+        # Settings
         if settings is None:
             settings = {}
         self.settings = lcn_defs.default_connection_settings
         self.settings.update(settings)
 
         self.idle_time = self.settings["BUS_IDLE_TIME"]
-
-        self.ping_timeout = self.settings["PING_TIMEOUT"] / 1000  # seconds
+        self.ping_send_delay = self.settings["PING_SEND_DELAY"]
+        self.ping_recv_timeout = self.settings["PING_RECV_TIMEOUT"]
+        self.ping_timeout_handle = None
         self.ping_counter = 0
-
         self.dim_mode = self.settings["DIM_MODE"]
         self.status_mode = lcn_defs.OutputPortStatusMode.PERCENT
 
@@ -251,8 +122,8 @@ class PchkConnectionManager(PchkConnection):
 
         # Events, Futures, Locks for synchronization
         self.segment_scan_completed_event = asyncio.Event()
-        self.authentication_completed_future: asyncio.Future[bool] = asyncio.Future()
-        self.license_error_future: asyncio.Future[bool] = asyncio.Future()
+        self.authentication_completed_future = asyncio.Future()
+        self.license_error_future = asyncio.Future()
         self.module_serial_number_received = asyncio.Lock()
         self.segment_coupler_response_received = asyncio.Lock()
 
@@ -265,6 +136,156 @@ class PchkConnectionManager(PchkConnection):
         self.segment_coupler_ids: list[int] = []
 
         self.input_callbacks: set[Callable[[inputs.Input], None]] = set()
+        self.event_callbacks: set[Callable[[LcnEvent], None]] = set()
+        self.register_for_events(self.event_callback)
+
+    # Socket read/write
+
+    async def read_data_loop(self) -> None:
+        """Processes incoming data."""
+        assert self.reader is not None
+        assert self.writer is not None
+        _LOGGER.debug("Read data loop started")
+        try:
+            while not self.writer.is_closing():
+                try:
+                    data = await self.reader.readuntil(
+                        PckGenerator.TERMINATION.encode()
+                    )
+                    self.last_bus_activity = time.time()
+                except (
+                    asyncio.IncompleteReadError,
+                    TimeoutError,
+                    OSError,
+                ):
+                    _LOGGER.debug("Connection to %s lost", self.connection_id)
+                    self.fire_event(LcnEvent.CONNECTION_LOST)
+                    await self.async_close()
+                    break
+
+                try:
+                    message = data.decode().split(PckGenerator.TERMINATION)[0]
+                except UnicodeDecodeError as err:
+                    _LOGGER.warning(
+                        "PCK decoding error: %s - skipping received PCK message", err
+                    )
+                    continue
+                await self.process_message(message)
+        except asyncio.CancelledError:
+            pass
+
+        _LOGGER.debug("Read data loop closed")
+
+    async def write_data_loop(self) -> None:
+        """Processes queue and writes data."""
+        assert self.writer is not None
+        try:
+            _LOGGER.debug("Write data loop started")
+            while not self.writer.is_closing():
+                data = await self.buffer.get()
+                while (time.time() - self.last_bus_activity) < self.idle_time:
+                    await asyncio.sleep(self.idle_time)
+
+                _LOGGER.debug(
+                    "to %s: %s",
+                    self.connection_id,
+                    data.decode().rstrip(PckGenerator.TERMINATION),
+                )
+                self.writer.write(data)
+                await self.writer.drain()
+                self.last_bus_activity = time.time()
+        except asyncio.CancelledError:
+            pass
+
+        # empty the queue
+        while not self.buffer.empty():
+            await self.buffer.get()
+
+        _LOGGER.debug("Write data loop closed")
+
+    # Open/close connection, authentication & setup.
+
+    async def async_connect(self, timeout: float = 30) -> None:
+        """Establish a connection to PCHK at the given socket."""
+        self.authentication_completed_future = asyncio.Future()
+        self.license_error_future = asyncio.Future()
+
+        _LOGGER.debug(
+            "Starting connection attempt to %s server at %s:%d",
+            self.connection_id,
+            self.host,
+            self.port,
+        )
+
+        done: Iterable[asyncio.Future[Any]]
+        pending: Iterable[asyncio.Future[Any]]
+        done, pending = await asyncio.wait(
+            (
+                asyncio.create_task(self.open_connection()),
+                self.license_error_future,
+                self.authentication_completed_future,
+            ),
+            timeout=timeout,
+            return_when=asyncio.FIRST_EXCEPTION,
+        )
+
+        # Raise any exception which occurs
+        # (ConnectionRefusedError, PchkAuthenticationError, PchkLicenseError)
+        for awaitable in done:
+            if not awaitable.cancelled():
+                if exc := awaitable.exception():
+                    await self.async_close()
+                    if isinstance(exc, (ConnectionRefusedError, OSError)):
+                        raise PchkConnectionRefusedError()
+                    else:
+                        raise awaitable.exception()  # type: ignore
+
+        if pending:
+            for awaitable in pending:
+                awaitable.cancel()
+            await self.async_close()
+            raise PchkConnectionFailedError()
+
+        if not self.is_lcn_connected:
+            raise PchkLcnNotConnectedError()
+
+        # start segment scan
+        await self.scan_segment_couplers(
+            self.settings["SK_NUM_TRIES"], self.settings["DEFAULT_TIMEOUT"]
+        )
+
+    async def open_connection(self) -> None:
+        """Connect to PCHK server (no authentication or license error check)."""
+        self.reader, self.writer = await asyncio.open_connection(self.host, self.port)
+
+        address = self.writer.get_extra_info("peername")
+        _LOGGER.debug("%s server connected at %s:%d", self.connection_id, *address)
+
+        # main write loop
+        self.task_registry.create_task(self.write_data_loop())
+
+        # main read loop
+        self.task_registry.create_task(self.read_data_loop())
+
+    async def async_close(self) -> None:
+        """Close the active connection."""
+        await self.cancel_requests()
+        if self.ping_timeout_handle is not None:
+            self.ping_timeout_handle.cancel()
+        await self.task_registry.cancel_all_tasks()
+        if self.writer:
+            self.writer.close()
+            try:
+                await self.writer.wait_closed()
+            except OSError:  # occurs when TCP connection is lost
+                pass
+
+        _LOGGER.debug("Connection to %s closed.", self.connection_id)
+
+    async def wait_closed(self) -> None:
+        """Wait until connection to PCHK server is closed."""
+        if self.writer is not None:
+            await self.writer.wait_closed()
 
     async def __aenter__(self) -> "PchkConnectionManager":
         """Context manager enter method."""
@@ -281,17 +302,6 @@ class PchkConnectionManager(PchkConnection):
         await self.async_close()
         return None
 
-    async def send_command(
-        self, pck: bytes | str, to_host: bool = False, **kwargs: Any
-    ) -> bool:
-        """Send a PCK command to the PCHK server.
-
-        :param    str    pck:    PCK command
-        """
-        if not self.is_lcn_connected and not to_host:
-            return False
-        return await super().send_command(pck)
-
     async def on_auth(self, success: bool) -> None:
         """Is called after successful authentication."""
         if success:
@@ -318,71 +328,30 @@ class PchkConnectionManager(PchkConnection):
         self.task_registry.create_task(self.ping())
 
     async def lcn_connection_status_changed(self, is_lcn_connected: bool) -> None:
-        """Set the current connection state to the LCN bus.
-
-        :param    bool    is_lcn_connected: Current connection status
-        """
+        """Set the current connection state to the LCN bus."""
         self.is_lcn_connected = is_lcn_connected
-        self.task_registry.create_task(
-            self.event_handler("lcn-connection-status-changed")
-        )
+        self.fire_event(LcnEvent.BUS_CONNECTION_STATUS_CHANGED)
         if is_lcn_connected:
             _LOGGER.debug("%s: LCN is connected.", self.connection_id)
-            self.task_registry.create_task(self.event_handler("lcn-connected"))
+            self.fire_event(LcnEvent.BUS_CONNECTED)
         else:
             _LOGGER.debug("%s: LCN is not connected.", self.connection_id)
-            self.task_registry.create_task(self.event_handler("lcn-disconnected"))
-
-    async def async_connect(self, timeout: int = 30) -> None:
-        """Establish a connection to PCHK at the given socket.
-
-        Ensures that the LCN bus is present and authorizes at PCHK.
-        Raise a :class:`TimeoutError`, if connection could not be established
-        within the given timeout.
-
-        :param    int    timeout:    Timeout in seconds
-        """
-        done: Iterable[asyncio.Future[Any]]
-        pending: Iterable[asyncio.Future[Any]]
-        done, pending = await asyncio.wait(
-            (
-                asyncio.create_task(super().async_connect()),
-                self.authentication_completed_future,
-                self.license_error_future,
-            ),
-            timeout=timeout,
-            return_when=asyncio.FIRST_EXCEPTION,
-        )
+            self.fire_event(LcnEvent.BUS_DISCONNECTED)
 
-        # Raise any exception which occurs
-        # (ConnectionRefusedError, PchkAuthenticationError, PchkLicenseError)
-        for awaitable in done:
-            if awaitable.exception():
-                raise awaitable.exception()  # type: ignore
+    async def ping_received(self, count: int | None) -> None:
+        """Ping was received."""
+        if self.ping_timeout_handle is not None:
+            self.ping_timeout_handle.cancel()
+        self.last_ping = time.time()
 
-        if pending:
-            for task in pending:
-                task.cancel()
-            raise TimeoutError(
-                f"Timeout error while connecting to {self.connection_id}."
-            )
+    def is_ready(self) -> bool:
+        """Retrieve the overall connection state."""
+        return self.segment_scan_completed_event.is_set()
 
-        # start segment scan
-        await self.scan_segment_couplers(
-            self.settings["SK_NUM_TRIES"], self.settings["DEFAULT_TIMEOUT_MSEC"]
-        )
-
-    async def async_close(self) -> None:
-        """Close the active connection."""
-        await self.cancel_requests()
-        await super().async_close()
-        _LOGGER.debug("Connection to %s closed.", self.connection_id)
+    # Addresses, modules and groups
 
     def set_local_seg_id(self, local_seg_id: int) -> None:
-        """Set the local segment id.
-
-        :param    int    local_seg_id:    The local segment_id.
-        """
+        """Set the local segment id."""
         old_local_seg_id = self.local_seg_id
 
         self.local_seg_id = local_seg_id
@@ -397,44 +366,17 @@ class PchkConnectionManager(PchkConnection):
                 self.address_conns[address_conn.addr] = address_conn
 
     def physical_to_logical(self, addr: LcnAddr) -> LcnAddr:
-        """Convert the physical segment id of an address to the logical one.
-
-        :param    addr:    The module's/group's address
-        :type     addr:    :class:`~LcnAddr`
-
-        :returns:    The module's/group's address
-        :rtype:      :class:`~LcnAddr`
-        """
+        """Convert the physical segment id of an address to the logical one."""
         return LcnAddr(
             self.local_seg_id if addr.seg_id in (0, 4) else addr.seg_id,
             addr.addr_id,
             addr.is_group,
         )
 
-    def is_ready(self) -> bool:
-        """Retrieve the overall connection state.
-
-        Nothing should be sent before this is signaled.
-
-        :returns:    True if everything is set-up, False otherwise
-        :rtype:      bool
-        """
-        return self.segment_scan_completed_event.is_set()
-
     def get_module_conn(
         self, addr: LcnAddr, request_serials: bool = True
     ) -> ModuleConnection:
-        """Create and/or return the given LCN module.
-
-        The ModuleConnection object is used for further communication
-        with the module (e.g. sending commands).
-
-        :param    addr:    The module's address
-        :type     addr:    :class:`~LcnAddr`
-
-        :returns: The address connection object (never null)
-        :rtype: `~ModuleConnection`
-        """
+        """Create and/or return the given LCN module."""
         assert not addr.is_group
         if addr.seg_id == 0 and self.local_seg_id != -1:
             addr = LcnAddr(self.local_seg_id, addr.addr_id, addr.is_group)
@@ -450,17 +392,7 @@ class PchkConnectionManager(PchkConnection):
         return address_conn
 
     def get_group_conn(self, addr: LcnAddr) -> GroupConnection:
-        """Create and return the GroupConnection for the given group.
-
-        The GroupConnection can be used for sending commands to all
-        modules that are static or dynamic members of the group.
-
-        :param    addr:    The group's address
-        :type     addr:    :class:`~LcnAddr`
-
-        :returns: The address connection object (never null)
-        :rtype: `~GroupConnection`
-        """
+        """Create and return the GroupConnection for the given group."""
         assert addr.is_group
         if addr.seg_id == 0 and self.local_seg_id != -1:
             addr = LcnAddr(self.local_seg_id, addr.addr_id, addr.is_group)
@@ -469,21 +401,13 @@ class PchkConnectionManager(PchkConnection):
     def get_address_conn(
         self, addr: LcnAddr, request_serials: bool = True
     ) -> AbstractConnection:
-        """Create and/or return an AbstractConnection to the given module or group.
-
-        The LCN module/group object is used for further communication
-        with the module/group (e.g. sending commands).
-
-        :param    addr:    The module's/group's address
-        :type     addr:    :class:`~LcnAddr`
-
-        :returns: The address connection object (never null)
-        :rtype: `~AbstractConnection`
-        """
+        """Create and/or return an AbstractConnection to the given module or group."""
         if addr.is_group:
             return self.get_group_conn(addr)
         return self.get_module_conn(addr, request_serials)
 
+    # Other
+
     def dump_modules(self) -> dict[str, dict[str, dict[str, Any]]]:
         """Dump all modules and information about them in a JSON serializable dict."""
         dump: dict[str, dict[str, dict[str, Any]]] = {}
@@ -495,19 +419,104 @@ class PchkConnectionManager(PchkConnection):
             dump[seg][addr] = address_conn.dump_details()
         return dump
 
-    async def scan_modules(self, num_tries: int = 3, timeout_msec: int = 3000) -> None:
+    # Command sending / retrieval.
+
+    async def send_command(
+        self, pck: bytes | str, to_host: bool = False, **kwargs: Any
+    ) -> bool:
+        """Send a PCK command to the PCHK server."""
+        if not self.is_lcn_connected and not to_host:
+            return False
+
+        assert self.writer is not None
+        if not self.writer.is_closing():
+            if isinstance(pck, str):
+                data = (pck + PckGenerator.TERMINATION).encode()
+            else:
+                data = pck + PckGenerator.TERMINATION.encode()
+            await self.buffer.put(data)
+            return True
+        return False
+
+    async def process_message(self, message: str) -> None:
+        """Is called when a new text message is received from the PCHK server."""
+        _LOGGER.debug("from %s: %s", self.connection_id, message)
+        inps = inputs.InputParser.parse(message)
+
+        if inps is not None:
+            for inp in inps:
+                await self.async_process_input(inp)
+
+    async def async_process_input(self, inp: inputs.Input) -> None:
+        """Process an input command."""
+        # Inputs from Host
+        if isinstance(inp, inputs.AuthUsername):
+            await self.send_command(self.username, to_host=True)
+        elif isinstance(inp, inputs.AuthPassword):
+            await self.send_command(self.password, to_host=True)
+        elif isinstance(inp, inputs.AuthOk):
+            await self.on_auth(True)
+        elif isinstance(inp, inputs.AuthFailed):
+            await self.on_auth(False)
+        elif isinstance(inp, inputs.LcnConnState):
+            await self.lcn_connection_status_changed(inp.is_lcn_connected)
+        elif isinstance(inp, inputs.LicenseError):
+            await self.on_license_error()
+        elif isinstance(inp, inputs.DecModeSet):
+            self.license_error_future.set_result(True)
+            await self.on_successful_login()
+        elif isinstance(inp, inputs.CommandError):
+            _LOGGER.debug("LCN command error: %s", inp.message)
+        elif isinstance(inp, inputs.Ping):
+            await self.ping_received(inp.count)
+        elif isinstance(inp, inputs.ModSk):
+            if inp.physical_source_addr.seg_id == 0:
+                self.set_local_seg_id(inp.reported_seg_id)
+            if self.segment_coupler_response_received.locked():
+                self.segment_coupler_response_received.release()
+            # store reported segment coupler id
+            if inp.reported_seg_id not in self.segment_coupler_ids:
+                self.segment_coupler_ids.append(inp.reported_seg_id)
+        elif isinstance(inp, inputs.Unknown):
+            return
+
+        # Inputs from bus
+        elif self.is_ready():
+            if isinstance(inp, inputs.ModInput):
+                logical_source_addr = self.physical_to_logical(inp.physical_source_addr)
+                if not logical_source_addr.is_group:
+                    module_conn = self.get_module_conn(logical_source_addr)
+                    if isinstance(inp, inputs.ModSn):
+                        # used to extend scan_modules() timeout
+                        if self.module_serial_number_received.locked():
+                            self.module_serial_number_received.release()
+
+                    await module_conn.async_process_input(inp)
+
+            # Forward all known inputs to callback listeners.
+            for input_callback in self.input_callbacks:
+                input_callback(inp)
+
+    async def ping(self) -> None:
+        """Send pings."""
+        assert self.writer is not None
+        while not self.writer.is_closing():
+            await self.send_command(f"^ping{self.ping_counter:d}", to_host=True)
+            self.ping_timeout_handle = asyncio.get_running_loop().call_later(
+                self.ping_recv_timeout, lambda: self.fire_event(LcnEvent.PING_TIMEOUT)
+            )
+            self.ping_counter += 1
+            await asyncio.sleep(self.ping_send_delay)
+
+    async def scan_modules(self, num_tries: int = 3, timeout: float = 3) -> None:
         """Scan for modules on the bus.
 
         This is a convenience coroutine which handles all the logic when
         scanning modules on the bus. Because of heavy bus traffic, not all
         modules might respond to a scan command immediately.
         The coroutine will make 'num_tries' attempts to send a scan command
-        and waits 'timeout_msec' after the last module response before
+        and waits 'timeout' after the last module response before
         proceeding to the next try.
-
-        :param      int     num_tries:      Scan attempts (default=3)
-        :param      int     timeout_msec:   Timeout in msec for each try
-                                            (default=3000)
         """
         segment_coupler_ids = (
             self.segment_coupler_ids if self.segment_coupler_ids else [0]
@@ -529,13 +538,13 @@ class PchkConnectionManager(PchkConnection):
                 try:
                     await asyncio.wait_for(
                         self.module_serial_number_received.acquire(),
-                        timeout_msec / 1000,
+                        timeout,
                     )
                 except asyncio.TimeoutError:
                     break
 
     async def scan_segment_couplers(
-        self, num_tries: int = 3, timeout_msec: int = 1500
+        self, num_tries: int = 3, timeout: float = 1.5
     ) -> None:
         """Scan for segment couplers on the bus.
 
@@ -543,12 +552,8 @@ class PchkConnectionManager(PchkConnection):
         scanning segment couplers on the bus. Because of heavy bus traffic,
         not all segment couplers might respond to a scan command immediately.
         The coroutine will make 'num_tries' attempts to send a scan command
-        and waits 'timeout_msec' after the last segment coupler response
+        and waits 'timeout' after the last segment coupler response
         before proceeding to the next try.
-
-        :param      int     num_tries:      Scan attempts (default=3)
-        :param      int     timeout_msec:   Timeout in msec for each try
-                                            (default=3000)
         """
         for _ in range(num_tries):
             await self.send_command(
@@ -563,7 +568,7 @@ class PchkConnectionManager(PchkConnection):
                 try:
                     await asyncio.wait_for(
                         self.segment_coupler_response_received.acquire(),
-                        timeout_msec / 1000,
+                        timeout,
                     )
                 except asyncio.TimeoutError:
                     break
@@ -574,76 +579,7 @@ class PchkConnectionManager(PchkConnection):
 
         self.segment_scan_completed_event.set()
 
-    async def ping(self) -> None:
-        """Send pings."""
-        assert self.writer is not None
-        while not self.writer.is_closing():
-            await self.send_command(f"^ping{self.ping_counter:d}", to_host=True)
-            self.ping_counter += 1
-            await asyncio.sleep(self.ping_timeout)
-
-    async def process_message(self, message: str) -> None:
-        """Is called when a new text message is received from the PCHK server.
-
-        This class should be reimplemented in any subclass which evaluates
-        received messages.
-
-        :param    str    input:    Input text message
-        """
-        await super().process_message(message)
-        inps = inputs.InputParser.parse(message)
-
-        if inps is not None:
-            for inp in inps:
-                await self.async_process_input(inp)
-
-    async def async_process_input(self, inp: inputs.Input) -> None:
-        """Process an input command."""
-        # Inputs from Host
-        if isinstance(inp, inputs.AuthUsername):
-            await self.send_command(self.username, to_host=True)
-        elif isinstance(inp, inputs.AuthPassword):
-            await self.send_command(self.password, to_host=True)
-        elif isinstance(inp, inputs.AuthOk):
-            await self.on_auth(True)
-        elif isinstance(inp, inputs.AuthFailed):
-            await self.on_auth(False)
-        elif isinstance(inp, inputs.LcnConnState):
-            await self.lcn_connection_status_changed(inp.is_lcn_connected)
-        elif isinstance(inp, inputs.LicenseError):
-            await self.on_license_error()
-        elif isinstance(inp, inputs.DecModeSet):
-            self.license_error_future.set_result(True)
-            await self.on_successful_login()
-        elif isinstance(inp, inputs.CommandError):
-            _LOGGER.debug("LCN command error: %s", inp.message)
-        elif isinstance(inp, inputs.ModSk):
-            if inp.physical_source_addr.seg_id == 0:
-                self.set_local_seg_id(inp.reported_seg_id)
-            if self.segment_coupler_response_received.locked():
-                self.segment_coupler_response_received.release()
-            # store reported segment coupler id
-            if inp.reported_seg_id not in self.segment_coupler_ids:
-                self.segment_coupler_ids.append(inp.reported_seg_id)
-        elif isinstance(inp, inputs.Unknown):
-            return
-
-        # Inputs from bus
-        elif self.is_ready():
-            if isinstance(inp, inputs.ModInput):
-                logical_source_addr = self.physical_to_logical(inp.physical_source_addr)
-                if not logical_source_addr.is_group:
-                    module_conn = self.get_module_conn(logical_source_addr)
-                    if isinstance(inp, inputs.ModSn):
-                        # used to extend scan_modules() timeout
-                        if self.module_serial_number_received.locked():
-                            self.module_serial_number_received.release()
-
-                    await module_conn.async_process_input(inp)
-
-            # Forward all known inputs to callback listeners.
-            for input_callback in self.input_callbacks:
-                input_callback(inp)
+    # Status requests, responses
 
     async def cancel_requests(self) -> None:
         """Cancel all TimeoutRetryHandlers."""
@@ -656,6 +592,8 @@ class PchkConnectionManager(PchkConnection):
         if cancel_tasks:
             await asyncio.wait(cancel_tasks)
 
+    # Callbacks for inputs and events
+
     def register_for_inputs(
         self, callback: Callable[[inputs.Input], None]
     ) -> Callable[..., None]:
@@ -666,20 +604,21 @@ class PchkConnectionManager(PchkConnection):
         self.input_callbacks.add(callback)
         return lambda callback=callback: self.input_callbacks.remove(callback)
 
-    def set_event_handler(self, coro: Callable[[str], Awaitable[None]]) -> None:
-        """Set the event handler for specific LCN events."""
-        if coro is None:
-            self.event_handler = self.default_event_handler
-        else:
-            self.event_handler = coro
+    def fire_event(self, event: LcnEvent) -> None:
+        """Fire event."""
+        for event_callback in self.event_callbacks:
+            event_callback(event)
 
-    async def default_event_handler(self, event: str) -> None:
-        """Handle events for specific LCN events."""
-        if event == "lcn-connected":
-            pass
-        elif event == "lcn-disconnected":
-            pass
-        elif event == "lcn-connection-status-changed":
-            pass
-        elif event == "connection-lost":
-            pass
+    def register_for_events(
+        self, callback: Callable[[lcn_defs.LcnEvent], None]
+    ) -> Callable[..., None]:
+        """Register a function for callback on LCN events.
+
+        Return a function to unregister the callback.
+        """
+        self.event_callbacks.add(callback)
+        return lambda callback=callback: self.event_callbacks.remove(callback)
+
+    def event_callback(self, event: LcnEvent) -> None:
+        """Handle events from PchkConnection."""
+        _LOGGER.debug("%s: LCN-Event: %s", self.connection_id, event)