titon 0.1.0__tar.gz

titon-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+dist/
+build/
+*.egg-info/
+.DS_Store

titon-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ugis Lazdins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

titon-0.1.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.5
+Name: titon
+Version: 0.1.0
+Summary: Async client for Titon Aura-T heat recovery ventilation units
+Project-URL: Homepage, https://github.com/ULazdins/titon
+Project-URL: Issues, https://github.com/ULazdins/titon/issues
+Author: Ugis Lazdins
+License-Expression: MIT
+License-File: LICENSE
+Keywords: aura-t,home-assistant,hrv,titon,ventilation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Home Automation
+Requires-Python: >=3.11
+Provides-Extra: cli
+Requires-Dist: aioconsole>=0.7; extra == 'cli'
+Description-Content-Type: text/markdown
+
+# titon
+
+Async Python client for [Titon Aura-T](https://www.titon.com/) heat recovery
+ventilation (HRV) units.
+
+The unit does not expose a local API. It keeps an outbound connection to
+Titon's relay at `app.manageiaq.com:6275`, and clients address a specific unit
+by its MAC address over that relay. This library speaks that protocol.
+
+> Reverse engineered from the vendor app's traffic. Unofficial and unaffiliated
+> with Titon. The protocol may change without notice.
+
+## Install
+
+```sh
+pip install titon
+```
+
+The interactive console needs one extra dependency:
+
+```sh
+pip install "titon[cli]"
+```
+
+## Usage
+
+```python
+import asyncio
+
+from titon import TitonClient, TitonFanSpeed
+
+
+async def main():
+    client = TitonClient("AA-BB-CC-11-22-33")  # your unit's MAC
+    await client.connect()
+
+    fan = TitonFanSpeed(client)
+    print("current fan speed:", await fan.perform())
+
+    await fan.set_to(3)
+
+    client.disconnect()
+
+
+asyncio.run(main())
+```
+
+Each capability is a small request object wrapping the client:
+
+| Class | Reads | Writes |
+| --- | --- | --- |
+| `TitonGeneralInfo` | temperatures, humidity, status flags | — |
+| `TitonFanSpeed` | current fan speed | `set_to(speed)` |
+| `TitonKitchenTimer` | kitchen boost timer | `set_to(minutes)` |
+| `TitonHandshake` | performed automatically by `connect()` | — |
+
+## Console
+
+```sh
+python -m titon.cli AA-BB-CC-11-22-33
+```
+
+Or set `TITON_HRV_MAC` and omit the argument. Commands: `info`, `fan`,
+`set fan`, `kitchen`, `set kitchen`, `quit`. Anything else is sent as a raw
+`DAT` message.
+
+## Protocol notes
+
+See [`docs/protocol.md`](docs/protocol.md) for the message framing, checksum,
+and the register notes gathered so far.
+
+## Home Assistant
+
+The Home Assistant integration built on this library lives at
+[ULazdins/titon-has](https://github.com/ULazdins/titon-has).
+
+## License
+
+MIT

titon-0.1.0/README.md

@@ -0,0 +1,79 @@
+# titon
+
+Async Python client for [Titon Aura-T](https://www.titon.com/) heat recovery
+ventilation (HRV) units.
+
+The unit does not expose a local API. It keeps an outbound connection to
+Titon's relay at `app.manageiaq.com:6275`, and clients address a specific unit
+by its MAC address over that relay. This library speaks that protocol.
+
+> Reverse engineered from the vendor app's traffic. Unofficial and unaffiliated
+> with Titon. The protocol may change without notice.
+
+## Install
+
+```sh
+pip install titon
+```
+
+The interactive console needs one extra dependency:
+
+```sh
+pip install "titon[cli]"
+```
+
+## Usage
+
+```python
+import asyncio
+
+from titon import TitonClient, TitonFanSpeed
+
+
+async def main():
+    client = TitonClient("AA-BB-CC-11-22-33")  # your unit's MAC
+    await client.connect()
+
+    fan = TitonFanSpeed(client)
+    print("current fan speed:", await fan.perform())
+
+    await fan.set_to(3)
+
+    client.disconnect()
+
+
+asyncio.run(main())
+```
+
+Each capability is a small request object wrapping the client:
+
+| Class | Reads | Writes |
+| --- | --- | --- |
+| `TitonGeneralInfo` | temperatures, humidity, status flags | — |
+| `TitonFanSpeed` | current fan speed | `set_to(speed)` |
+| `TitonKitchenTimer` | kitchen boost timer | `set_to(minutes)` |
+| `TitonHandshake` | performed automatically by `connect()` | — |
+
+## Console
+
+```sh
+python -m titon.cli AA-BB-CC-11-22-33
+```
+
+Or set `TITON_HRV_MAC` and omit the argument. Commands: `info`, `fan`,
+`set fan`, `kitchen`, `set kitchen`, `quit`. Anything else is sent as a raw
+`DAT` message.
+
+## Protocol notes
+
+See [`docs/protocol.md`](docs/protocol.md) for the message framing, checksum,
+and the register notes gathered so far.
+
+## Home Assistant
+
+The Home Assistant integration built on this library lives at
+[ULazdins/titon-has](https://github.com/ULazdins/titon-has).
+
+## License
+
+MIT

titon-0.1.0/docs/protocol.md

@@ -0,0 +1,85 @@
+FilterChangeActivity
+    SF1 ?
+    SF01%03d ?
+
+FunMainActivity
+    L
+    Z - ja saņem <zck>
+
+    SD01 - SD07 - dabūt datumus?
+    F1-F4 - uzstādīt ātrumus
+
+    ST0xxxx - uzstādīt taimeri? - "Please confirm that you want to update the aura-t display time and day?"
+
+OtherSettingActivity
+    SK10 - virtuves taimeris
+    SW10 - vannas taimeris
+
+    SW0xxx, SK0xxx - uzstādīt taimerus uz xxx (0-100)
+
+PHSettingActivity
+    SH1000 - nolasa mitruma līmeni
+        atbild ar SH065040 - 65%
+
+    SH0xxx - uzstāda mitruma līmeni
+
+PwmSettingActivity
+    Gaisa intake/outtake
+    C010 - C710
+
+    CS - uzsāk transaction?
+    C00xxxx - uzstāda gaisa intake, outtake xxxx (0-100)
+    CE - beidz transaction? Vai arī nobloķē edit, atbloķē edit?
+
+SummerSettingActivity
+
+    SS1000 - initial message?, atgriež SS 190 056, kur no 190 - 19.0 grādi
+
+    SE1000 - atgriež SE 250 033, kur 250 - 25.0 grādi
+
+    SB10 - atgriež SB 0 033, kur 0 ir "Summer boost disable" izslēgts
+
+
+    SBx - ieslēgt/izslēgt summer bypass
+
+    SE0xxx - uzstādīt Summer Extract
+    SS0xxx - uzstādīt Summer Supply
+
+SwitchSelectActivity
+    X010 - X410 - četri slēdžu uzstādījumi - atbild ar X 2 05 111, kur 2 - slēdža kods (no pieprasījuma, 05 - istabas kods)
+
+
+        1 - getString(R.string.wetRoomBoost), 
+        2- getString(R.string.kitchenBoost), 
+        getString(R.string.setBack), ??
+        getString(R.string.summerBoostDisable), 
+        getString(R.string.fanSpeed4), 
+        getString(R.string.fansOff_o), "Fans off (N/O)"
+        getString(R.string.fansOff_c), "Fans off (N/C)"
+        8 - getString(R.string.manualSummerBypass)
+
+
+    X00xx - saglabā slēdža uzstādījumus, xx - istabas kods
+
+TimerSetActivity
+    TM1 - nolasa taimera statusu, saņem TM1 0 40, kur 0 - nav ieslēgts
+    TM0x - uzstāda taimer uz x
+
+
+
+
+
+
+
+message_get_fan_1_speed_in = get_full_message("C010")
+message_get_fan_1_speed_out = get_full_message("C110")
+message_get_fan_2_speed_in = get_full_message("C210")
+message_get_fan_2_speed_out = get_full_message("C310")
+message_get_fan_3_speed_in = get_full_message("C410")
+message_get_fan_3_speed_out = get_full_message("C510")
+message_get_fan_4_speed_in = get_full_message("C610")
+message_get_fan_4_speed_out = get_full_message("C710")
+
+
+message_get_fan_speed = get_full_message("L")
+message_get_fan_speed_ack = f":DAT|{hrv_mac}|{my_mac}|PS"

titon-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "titon"
+version = "0.1.0"
+description = "Async client for Titon Aura-T heat recovery ventilation units"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+authors = [{ name = "Ugis Lazdins" }]
+keywords = ["titon", "aura-t", "hrv", "ventilation", "home-assistant"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Home Automation",
+]
+dependencies = []
+
+[project.optional-dependencies]
+cli = ["aioconsole>=0.7"]
+
+[project.urls]
+Homepage = "https://github.com/ULazdins/titon"
+Issues = "https://github.com/ULazdins/titon/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/titon"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/titon", "docs", "README.md", "LICENSE"]

titon-0.1.0/src/titon/TitonClient.py

@@ -0,0 +1,147 @@
+import asyncio
+import logging
+
+from .helpers import get_symbol_hash
+from .TitonHandshake import TitonHandshake
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class TitonClient:
+    messages = []
+    callbacks = []
+    my_mac = "12-34-56-78-12-34"
+    is_connected = False
+    is_connecting = False
+    connecting_callbacks = []
+
+    def __init__(self, hrv_mac):
+        self.hrv_mac = hrv_mac
+
+    async def connect(self):
+        _LOGGER.debug("-- connecting")
+
+        if self.is_connected:
+            _LOGGER.debug("-- connected\n")
+            return
+
+        if self.is_connecting:
+            _LOGGER.debug("-- already connecting; reusing existing process\n")
+            future = asyncio.Future()
+            self.connecting_callbacks.append(future)
+            return future
+
+        self.is_connecting = True
+
+        try:
+            self.reader, self.writer = await asyncio.open_connection(
+                "app.manageiaq.com", 6275
+            )
+
+            reader_task = asyncio.ensure_future(self.receive_messages_loop(self.reader))
+            asyncio.ensure_future(self.send_messages_loop(self.writer))
+            reader_task.add_done_callback(self.handle_future_exception)
+
+            handhske = TitonHandshake(self)
+            await handhske.perform()
+            _LOGGER.debug("-- connected\n")
+
+            # A success
+            self.is_connecting = False
+            self.is_connected = True
+
+            for x in self.connecting_callbacks:
+                x.set_result(True)
+            self.connecting_callbacks = []
+
+        except (BaseException, ValueError) as e:
+            _LOGGER.debug("-- connection failed\n")
+
+            # A failure
+            self.is_connecting = False
+            self.is_connected = False
+
+            for x in self.connecting_callbacks:
+                x.set_exception(e)
+            self.connecting_callbacks = []
+
+    def handle_future_exception(self, future):
+        exception = future.exception()
+        if exception:
+            _LOGGER.debug(f"An exception occurred: {exception}")
+
+            self.disconnect()
+
+    def disconnect(self):
+        self.writer.close()
+
+        self.is_connected = False
+        _LOGGER.debug("-- disconnected")
+
+    async def receive_messages_loop(self, reader):
+        while True:
+            data = await reader.readuntil(b";")
+            if not data:
+                break
+
+            string = data.decode()
+            _LOGGER.debug(f"<<< {string}")
+
+            for callback in self.callbacks:
+                callback(string)
+
+    async def send_messages_loop(self, writer):
+        while True:
+            try:
+                message = self.messages.pop()
+                message = message
+                _LOGGER.debug(f">>> {message}")
+                writer.write(message.encode())
+                await writer.drain()
+            except IndexError:
+                pass
+            except Exception as e:
+                _LOGGER.error(f"Write failed with {e}")
+
+            # Let the loop breathe
+            await asyncio.sleep(0.1)
+
+    def get_full_message(self, msg):
+        payload = f"{msg}{ '%03d' % get_symbol_hash(msg) }"
+        return f":DAT|{self.hrv_mac}|{self.my_mac}|<stx>{payload}<etx>;"
+
+    async def send_request_response(self, request, check_if_wants_to_handle_response):
+        future = asyncio.Future()
+
+        # Send message
+        self.messages.append(request)
+
+        # Await response
+        def callback(message):
+            if check_if_wants_to_handle_response(message):
+                future.set_result(message)
+                self.callbacks.remove(callback)
+
+        self.callbacks.append(callback)
+
+        # Timeout handling
+        async def schedule_timeout_job():
+            await asyncio.sleep(5)
+
+            if not future.done():
+                _LOGGER.debug("- handling timeout")
+                self.callbacks.remove(callback)
+
+                self.is_connected = False
+
+                future.set_exception(ValueError("Timeout"))
+
+        loop = asyncio.get_event_loop()
+        loop.create_task(schedule_timeout_job())
+
+        # Return future
+        return await future
+
+    async def send_dat_message(self, message):
+        payload = self.get_full_message(message)
+        self.messages.append(payload)

titon-0.1.0/src/titon/TitonFanSpeed.py

@@ -0,0 +1,80 @@
+import logging
+
+from .helpers import get_symbol_hash, get_after_last_pipe, split_into_bits
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class TitonFanSpeed:
+    update_callbacks = []
+
+    def __init__(self, client):
+        self.client = client
+        self.value = None
+
+        self.message = f":DAT|{self.client.hrv_mac}|{self.client.my_mac}|<stx>L{ '%03d' % get_symbol_hash('L') }<etx>;"
+        self.response_prefix = (
+            f":DAT|{self.client.hrv_mac}|{self.client.my_mac}|PS|<stx>L"
+        )
+
+    async def perform(self):
+        response = await self.client.send_request_response(
+            self.message,
+            lambda x: x.startswith(self.response_prefix),
+        )
+
+        payload = get_after_last_pipe(response)
+        payload = payload.removeprefix("<stx>").removesuffix("<etx>;")
+
+        byte1 = payload[4:6]
+
+        bits1 = split_into_bits(int(byte1, 16))
+
+        value = 0
+        for x in range(0, 4):
+            if bits1[x] != 0:
+                value = x + 1
+                break
+
+        self.set_value(value)
+
+        return value
+
+    async def set_to(self, value):
+        try:
+            if value < 0 or value > 4:
+                return False
+
+            message = self.client.get_full_message(f"F{ '%d' % value }")
+            response_prefix = (
+                f":DAT|{self.client.hrv_mac}|{self.client.my_mac}|PS|<stx>F"
+            )
+
+            if not self.client.is_connected:
+                await self.client.connect()
+
+            response = await self.client.send_request_response(
+                message,
+                lambda x: x.startswith(response_prefix),
+            )
+
+            payload = get_after_last_pipe(response)
+            payload = payload.removeprefix("<stx>").removesuffix("<etx>;")
+
+            success = payload == "F<ack>"
+
+            if success:
+                self.set_value(value)
+
+            return success
+        except Exception as e:
+            _LOGGER.exception(f"Failed to set fan speed ${e}")
+
+    def set_value(self, value):
+        notify_observers = self.value != value
+        self.value = value
+
+        if notify_observers:
+            for callback in self.update_callbacks:
+                callback()

titon-0.1.0/src/titon/TitonGeneralInfo.py

@@ -0,0 +1,55 @@
+import logging
+
+from .helpers import get_symbol_hash, get_after_last_pipe, split_into_bits
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class TitonGeneralInfo:
+    def __init__(self, client):
+        self.client = client
+
+        self.message = f":DAT|{self.client.hrv_mac}|{self.client.my_mac}|<stx>L{ '%03d' % get_symbol_hash('L') }<etx>;"
+        self.response_prefix = (
+            f":DAT|{self.client.hrv_mac}|{self.client.my_mac}|PS|<stx>L"
+        )
+
+    async def perform(self):
+        response = await self.client.send_request_response(
+            self.message,
+            lambda x: x.startswith(self.response_prefix),
+        )
+
+        payload = get_after_last_pipe(response)
+        payload = payload.removeprefix("<stx>").removesuffix("<etx>;")
+
+        byte1 = payload[4:6]
+        byte2 = payload[10:12]
+        byte3 = payload[16:18]
+
+        bits1 = split_into_bits(int(byte1, 16))
+        bits2 = split_into_bits(int(byte2, 16))
+        bits3 = split_into_bits(int(byte3, 16))
+
+        # FunModel
+        _LOGGER.debug(f"Byte1 {bits1}")
+        _LOGGER.debug(f"Speed1 {bits1[0]}")
+        _LOGGER.debug(f"Speed2 {bits1[1]}")
+        _LOGGER.debug(f"Speed3 {bits1[2]}")
+        _LOGGER.debug(f"Speed4 {bits1[3]}")
+        _LOGGER.debug(f"Timer {bits1[4]}")
+        _LOGGER.debug(f"Switch {bits1[5]}")
+
+        _LOGGER.debug(f"\nByte2 {bits2}")
+        _LOGGER.debug(f"Sensor {bits2[0]}")
+        _LOGGER.debug(f"Filter {bits2[1]}")
+        _LOGGER.debug(f"Inhibit {bits2[2]}")
+        _LOGGER.debug(f"Boost {bits2[3]}")
+        _LOGGER.debug(f"Frost {bits2[4]}")
+        _LOGGER.debug(f"Internal {bits2[5]}")
+
+        _LOGGER.debug(f"\nByte3 {bits3}")
+        _LOGGER.debug(f"Summer {bits3[0]}")
+        _LOGGER.debug(f"Attention {bits3[1]}")
+        _LOGGER.debug(f"Duct heater {bits3[2]}")

titon-0.1.0/src/titon/TitonHandshake.py

@@ -0,0 +1,21 @@
+class TitonHandshake:
+    def __init__(self, client):
+        self.client = client
+
+        self.message_handshake = f":DLF||{client.my_mac};"
+        self.message_handshake_ack = f":DLF||{client.my_mac}|PS;"
+        self.message_register_hrv = f":_CX|{client.hrv_mac}|0;"
+        self.message_register_hrv_ack = (
+            f":_CX|{client.hrv_mac}|0|PS;"  # FA - response if HRV not found
+        )
+
+    async def perform(self):
+        await self.client.send_request_response(
+            self.message_handshake,
+            lambda x: x == self.message_handshake_ack,
+        )
+
+        await self.client.send_request_response(
+            self.message_register_hrv,
+            lambda x: x == self.message_register_hrv_ack,
+        )

titon-0.1.0/src/titon/TitonKitchenTimer.py

@@ -0,0 +1,57 @@
+from .helpers import get_symbol_hash, get_after_last_pipe
+
+
+class TitonKitchenTimer:
+    update_callbacks = []
+    value = None
+
+    def __init__(self, client):
+        self.client = client
+
+    async def perform(self):
+        message = f":DAT|{self.client.hrv_mac}|{self.client.my_mac}|<stx>SK10{ '%03d' % get_symbol_hash('SK10') }<etx>;"
+        response_prefix = f":DAT|{self.client.hrv_mac}|{self.client.my_mac}|PS|<stx>SK"
+
+        response = await self.client.send_request_response(
+            message,
+            lambda x: x.startswith(response_prefix),
+        )
+
+        payload = get_after_last_pipe(response)
+        payload = payload.removeprefix("<stx>").removesuffix("<etx>;")
+
+        byte1 = payload[2:5]
+
+        self.set_value(int(byte1, 10))
+
+        return self.value
+
+    async def set_to(self, value):
+        if value < 0 or value > 100:
+            pass
+
+        message = self.client.get_full_message(f"SK0{ '%03d' % value }")
+        response_prefix = f":DAT|{self.client.hrv_mac}|{self.client.my_mac}|PS|<stx>S"
+
+        response = await self.client.send_request_response(
+            message,
+            lambda x: x.startswith(response_prefix),
+        )
+
+        payload = get_after_last_pipe(response)
+        payload = payload.removeprefix("<stx>").removesuffix("<etx>;")
+
+        success = payload == "S<ack>"
+
+        if success:
+            self.set_value(value)
+
+        return success
+
+    def set_value(self, value):
+        notify_observers = self.value != value
+        self.value = value
+
+        if notify_observers:
+            for callback in self.update_callbacks:
+                callback()

titon-0.1.0/src/titon/__init__.py

@@ -0,0 +1,18 @@
+"""Async client for Titon Aura-T heat recovery ventilation units."""
+
+from .TitonClient import TitonClient
+from .TitonFanSpeed import TitonFanSpeed
+from .TitonGeneralInfo import TitonGeneralInfo
+from .TitonHandshake import TitonHandshake
+from .TitonKitchenTimer import TitonKitchenTimer
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "TitonClient",
+    "TitonFanSpeed",
+    "TitonGeneralInfo",
+    "TitonHandshake",
+    "TitonKitchenTimer",
+    "__version__",
+]

titon-0.1.0/src/titon/cli.py

@@ -0,0 +1,95 @@
+"""Interactive console for poking at a Titon HRV unit.
+
+Run with the unit's MAC address:
+
+    python -m titon.cli AA-BB-CC-11-22-33
+
+or set TITON_HRV_MAC in the environment.
+"""
+
+import asyncio
+import logging
+import os
+import sys
+
+import aioconsole
+
+from .TitonClient import TitonClient
+from .TitonFanSpeed import TitonFanSpeed
+from .TitonGeneralInfo import TitonGeneralInfo
+from .TitonKitchenTimer import TitonKitchenTimer
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def main(client):
+    kitchen_request = TitonKitchenTimer(client)
+    info_request = TitonGeneralInfo(client)
+    fan_request = TitonFanSpeed(client)
+
+    while True:
+        print("\n")
+        user_input = await aioconsole.ainput("Enter command: ")
+        print("\n")
+
+        if not client.is_connected:
+            await client.connect()
+
+        if user_input.lower() == "quit":
+            print("Closing the connection")
+            break
+        elif user_input == "kitchen":
+            response = await kitchen_request.perform()
+
+            print(f"Kitchen timer is set to {response}")
+        elif user_input == "set kitchen":
+            value = kitchen_request.value + 1
+
+            response = await kitchen_request.set_to(value)
+
+            if response:
+                print(f"Kitchen timer is set to {value}")
+            else:
+                print("Setting timer failed")
+        elif user_input == "fan":
+            response = await fan_request.perform()
+
+            print(f"Fan speed is set to {response}")
+        elif user_input == "set fan":
+            value = await aioconsole.ainput("Enter value: ")
+            value = int(value)
+
+            response = await fan_request.set_to(value)
+
+            if response:
+                print(f"Fan speed is set to {value}")
+            else:
+                print("Setting fan speed failed")
+        elif user_input == "info":
+            await info_request.perform()
+        else:
+            await client.send_dat_message(user_input)
+
+
+def run():
+    """Entry point: resolve the MAC, then run the console."""
+    mac = sys.argv[1] if len(sys.argv) > 1 else os.environ.get("TITON_HRV_MAC")
+
+    if not mac:
+        sys.exit(
+            "No HRV MAC address given.\n"
+            "Usage: python -m titon.cli <MAC>   (e.g. AA-BB-CC-11-22-33)\n"
+            "   or: set TITON_HRV_MAC in the environment."
+        )
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format="%(name)s - %(levelname)s - %(message)s",
+        handlers=[logging.StreamHandler()],
+    )
+
+    asyncio.run(main(TitonClient(mac)))
+
+
+if __name__ == "__main__":
+    run()

titon-0.1.0/src/titon/helpers.py

@@ -0,0 +1,33 @@
+from functools import reduce
+
+
+def get_symbol_hash(msg):
+    chars = [ord(x) for x in msg]
+
+    def xor(x, y):
+        return x ^ y
+
+    return reduce(xor, chars)
+
+
+def get_after_last_pipe(input_string):
+    parts = input_string.rsplit("|", 1)
+
+    if len(parts) > 1:
+        return parts[1]
+    else:
+        # If no pipe is found, return the original string
+        return input_string
+
+
+def split_into_bits(number):
+    # Use bin() to get the binary representation and remove the '0b' prefix
+    binary_representation = bin(number)[2:]
+
+    # Pad with leading zeros to ensure a consistent length
+    padded_binary = binary_representation.zfill(8)  # Assuming 8 bits for simplicity
+
+    # Convert the binary string to a list of integers
+    bits = [int(bit) for bit in padded_binary]
+
+    return bits