btbricks 0.2.1__py3-none-any.whl

btbricks/bthub.py

@@ -0,0 +1,218 @@
+import struct
+try:
+    from micropython import const
+    from time import sleep_ms
+except:
+    def const(x):
+        return x
+    def sleep_ms(x):
+        pass
+try:
+    from .bt import BLEHandler
+except:
+    from bt import BLEHandler
+
+__HUB_NOTIFY_DESC = const(0x0F)
+__REMOTE_NOTIFY_DESC = const(0x0C)
+__MARIO_NOTIFY_DESC = const(14)
+__HUB_PORT_ACC = const(0x61)
+__HUB_PORT_GYRO = const(0x62)
+__HUB_PORT_TILT = const(0x63)
+
+_MODE = const(0)
+_MODE_BYTE = const(1)
+_MODE_DATA_SETS = const(2)
+_MODE_DATA_SET_TYPE = const(3)
+
+OFF = const(0)
+PINK = const(1)
+PURPLE = const(2)
+DARK_BLUE = const(3)
+BLUE = const(4)
+TEAL = const(5)
+GREEN = const(6)
+YELLOW = const(7)
+ORANGE = const(8)
+RED = const(9)
+WHITE = const(10)
+
+def clamp_int(n, floor=-100, ceiling=100):
+    return max(min(round(n), ceiling), floor)
+
+class BtHub():
+    """
+    BtHub
+
+    A class for connecting to and controlling LEGO Hub devices via Bluetooth Low Energy (BLE).
+
+    This class provides an interface to communicate with LEGO Smart Hubs running standard LEGO firmware.
+    It handles BLE connection management, motor control, sensor data subscription, and LED control.
+
+    :param ble_handler: Optional BLEHandler instance for managing BLE connections. If None, a new BLEHandler will be created.
+    :type ble_handler: BLEHandler, optional
+
+    :raises ConnectionError: If the BLE connection to the hub fails.
+
+    Example::
+
+        hub = BtHub()
+        hub.connect()
+        hub.dc(1, 50)  # Run motor on port 1 at 50%
+        acceleration = hub.acc()  # Get accelerometer data
+        hub.disconnect()
+
+    Attributes:
+        ble_handler (BLEHandler): Handler for BLE communication operations
+        _conn_handle: Internal connection handle for the active BLE connection
+        acc_sub (bool): Flag indicating if accelerometer subscription is active
+        gyro_sub (bool): Flag indicating if gyroscope subscription is active
+        tilt_sub (bool): Flag indicating if tilt subscription is active
+        hub_data (dict): Dictionary storing sensor data by port
+        mode_info (dict): Dictionary storing mode information by port
+    """
+    
+    __PORTS = {
+        1:0, 2:1, 3:2, 4:3,
+        "A":0, "B":1, "C":2, "D":3}
+
+    def __init__(self, ble_handler:BLEHandler=None):
+        if ble_handler is None:
+            ble_handler = BLEHandler()
+        self.ble_handler = ble_handler
+        self._conn_handle = None
+        self.acc_sub = False
+        self.gyro_sub = False
+        self.tilt_sub = False
+        self.hub_data = {}
+        self.mode_info = {}
+
+    def is_connected(self):
+        return self._conn_handle is not None
+
+    def connect(self):
+        self._conn_handle = self.ble_handler.connect_lego()
+        if self._conn_handle is not None:
+            sleep_ms(500)
+            # Subscribe to motion data of SMART Hubs
+            self.write(0x0A, 0x00, 0x41, __HUB_PORT_ACC, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01)
+            sleep_ms(200)
+            self.write(0x0A, 0x00, 0x41, __HUB_PORT_GYRO, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01)
+            sleep_ms(200)
+            self.write(0x0A, 0x00, 0x41, __HUB_PORT_TILT, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01)
+            sleep_ms(200)
+
+            # Initialize all ports with mode 0
+            mode = 0
+            for i in range(4):
+                # SUBSCRIBE_MODE
+                self.write(0x0A,0x00,0x41, i, mode, 0x01, 0x00, 0x00, 0x00, 0x01)
+                sleep_ms(100)
+                # GET_MODE_INFO
+                self.write(0x06, 0x00, 0x22, i, mode, 0x80)
+                sleep_ms(100)
+
+            # Enable notify on smart hubs
+            self.ble_handler.enable_notify(self._conn_handle, __HUB_NOTIFY_DESC, self.__on_notify)
+            sleep_ms(200)
+            self.set_led_color(GREEN)
+        else:
+            print("Connection failed")
+
+    def disconnect(self):
+        if self._conn_handle is not None:
+            self.ble_handler.disconnect(self._conn_handle)
+            self._conn_handle = None
+
+    def write(self, *data):
+        self.ble_handler.lego_write(
+            struct.pack("%sB" % len(data), *data),
+            self._conn_handle
+            )
+
+    def set_led_color(self, idx):
+        self.write(0x08, 0x00, 0x81, 0x32, 0x11, 0x51, 0x00, idx)
+
+    def set_remote_led_color(self, idx):
+        self.write(0x08, 0x00, 0x81, 0x34, 0x11, 0x51, 0x00, idx)
+
+    def __on_notify(self, data):
+        # hub = data[1]
+        message_type = data[2]
+        port = data[3]
+        payload = data[4:]
+        if message_type == 0x45:
+            self.hub_data[port] = payload
+        elif message_type == 0x44:
+            self.mode_info[port] = {
+                _MODE : payload[0],
+                _MODE_BYTE : payload[1],
+                _MODE_DATA_SETS : payload[2],
+                _MODE_DATA_SET_TYPE : payload[3],
+            }
+
+    def unpack_data(self, port, fmt="3h"):
+        if port in self.hub_data.keys():
+            return struct.unpack(fmt, self.hub_data[port])
+
+    def acc(self):
+        return self.unpack_data(__HUB_PORT_ACC)
+
+    def gyro(self):
+        return self.unpack_data(__HUB_PORT_GYRO)
+
+    def tilt(self):
+        return self.unpack_data(__HUB_PORT_TILT)
+
+    def dc(self, port, pct):
+        self.write(0x06, 0x00, 0x81, self.__PORTS[port], 0x11, 0x51, 0x00, clamp_int(pct))
+
+    def run_target(self, port, degrees, speed=50, max_power=100, acceleration=100, deceleration=100, stop_action=0):
+        degree_bits = struct.unpack("<BBBB", struct.pack("<i", degrees))
+        self.write(0x0D, 0x00, 0x81, self.__PORTS[port], 0x11, 0x0D, degree_bits[0], degree_bits[1], degree_bits[2], degree_bits[3], speed, max_power, 0x7E)
+
+    def mode(self, port, mode, *data):
+        # set_mode
+        self.write(0x0A,0x00,0x41, self.__PORTS[port], mode, 0x01, 0x00, 0x00, 0x00, 0x01)
+        sleep_ms(100)
+        if data:
+            self.write(7+len(data), 0x00, 0x81, self.__PORTS[port], 0x00, 0x51, mode, *data)
+            sleep_ms(100)
+        # request_mode_info
+        self.write(0x06, 0x00, 0x22, self.__PORTS[port], mode, 0x80)
+        sleep_ms(100)
+
+    def run(self, port, speed, max_power=100, acceleration=100, deceleration=100):
+        # Start motor at given speed
+        self.write(0x09, 0x00, 0x81, self.__PORTS[port], 0x11, 0x07, clamp_int(speed), max_power, 0x00)
+
+    def run_time(self, port, time, speed=50, max_power=100, acceleration=100, deceleration=100, stop_action=0):
+        # Rotate motor for a given time
+        time_bits = struct.unpack("<BB", struct.pack("<H", time))
+        self.write(0x0B, 0x00, 0x81, self.__PORTS[port], 0x11, 0x09, time_bits[0], time_bits[1], speed, max_power, 0x00)
+
+    def run_angle(self, port, degrees, speed=50, max_power=100, acceleration=100, deceleration=100, stop_action=0):
+        # Rotate motor for a given number of degrees relative to current position
+        degree_bits = struct.unpack("<BBBB", struct.pack("<i", degrees))
+        self.write(0x0D, 0x00, 0x81, self.__PORTS[port], 0x11, 0x0B, degree_bits[0], degree_bits[1], degree_bits[2], degree_bits[3], speed, max_power, 0x7E)
+
+    def get(self, port):
+        port = self.__PORTS[port]
+        if port in self.hub_data:
+            value = None
+            payload = self.hub_data[port]
+            no_data_sets = None
+            data_set_type = 0
+            if port in self.mode_info:
+                data_set_type = self.mode_info[port][_MODE_DATA_SET_TYPE]
+                no_data_sets = self.mode_info[port][_MODE_DATA_SETS]
+
+            if data_set_type == 0x00:
+                message = struct.unpack("%sb" % len(payload), payload)
+                value = message[:no_data_sets]
+            elif data_set_type == 0x01:
+                message = struct.unpack("%sh" % (len(payload)//2), payload)
+                value = message[:no_data_sets]
+            elif data_set_type == 0x02:
+                message = struct.unpack("%si" % (len(payload)//4), payload)
+                value = message[:no_data_sets]
+            return value

btbricks/ctrl_plus.py

@@ -0,0 +1,8 @@
+from .bthub import BtHub
+
+# Backward compatibility
+class SmartHub(BtHub):
+    """
+    This class is kept for backward compatibility. Use :class:`BtHub` instead.
+    """
+    pass

btbricks-0.2.1.dist-info/METADATA

@@ -0,0 +1,232 @@
+Metadata-Version: 2.4
+Name: btbricks
+Version: 0.2.1
+Summary: A MicroPython Bluetooth library for remote controlling LEGO hubs via BLE
+Home-page: https://github.com/antonvh/btbricks
+Author: Anton Vanhoucke
+Author-email: Anton Vanhoucke <anton@antonsmindstorms.com>
+License: MIT
+Project-URL: Homepage, https://github.com/antonvh/btbricks
+Project-URL: Documentation, https://docs.antonsmindstorms.com/en/latest/Software/btbricks/docs/index.html
+Project-URL: Repository, https://github.com/antonvh/btbricks.git
+Project-URL: Issues, https://github.com/antonvh/btbricks/issues
+Keywords: micropython,bluetooth,ble,lego,hub,control
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: Implementation :: MicroPython
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Hardware
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.20.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: flake8>=5.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=4.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.0; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints>=1.12; extra == "docs"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# btbricks
+
+<img alt="btbricks logo" src="https://raw.githubusercontent.com/antonvh/btbricks/master/img/btbricks.png" width="200">
+
+[![PyPI Version](https://img.shields.io/pypi/v/btbricks.svg)](https://pypi.org/project/btbricks/)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![MicroPython](https://img.shields.io/badge/MicroPython-compatible-orange.svg)](https://micropython.org/)
+
+A MicroPython Bluetooth library. It implements BLE (Bluetooth 5, Bluetooth Low Energy). Of the know BLE services, this library implements Nordic Uart Service (NUS), LEGO Service and MIDI service. The library contains both the BLE Central (client) and BLE Peripheral (server) classes.
+
+These BLE services allow for controlling LEGO hubs, running official firmware. The services also allow creating custom Bluetooth peripherals: RC controllers, MIDI devices, etc. To control the LEGO hubs, you can best use a [hub expansion board, like the LMS-ESP32](https://www.antonsmindstorms.com/product/wifi-python-esp32-board-for-mindstorms/).
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Documentation](#documentation-and-api-reference)
+- [Supported Platforms](#supported-platforms)
+- [Firmware Notes](#firmware-notes)
+- [License](#license)
+- [Author](#author)
+
+## Features
+
+- 🔌 **BLE Communication**: Comprehensive Bluetooth Low Energy support via MicroPython's `ubluetooth`
+- 🎮 **Hub Control**: Control LEGO MINDSTORMS hubs, SPIKE sets, and smart hubs over Bluetooth
+- 📱 **Custom Peripherals**: Create RC controllers, MIDI controllers, and other BLE peripherals compatible with LEGO hubs
+- 🚀 **MicroPython Ready**: Optimized for MicroPython on ESP32, LEGO SPIKE, and other platforms
+- 📡 **LEGO Protocol**: Full support for LEGO Bluetooth protocols (LPF2, LPUP, CTRL+)
+- 🎛️ **Multiple Interfaces**: Nordic UART, MIDI, RC control, and native LEGO hub communication
+- ⚙️ **Advanced BLE**: Automatic MTU negotiation, descriptor handling, and efficient payload management
+
+## Installation
+
+### On LMS-ESP32
+
+The module should be included in the latest Micropython firmware from <https://wwww.antonsmindstorms.com>. If not, use ViperIDE or Thonny and create a new file called rcservo.py.
+Copy the contents from the same file in this repository inside.
+
+### On MicroPython device using `micropip` from PyPI
+
+```python
+import micropip
+await micropip.install("btbricks")
+```
+
+Note: `micropip` must be available on the target board and may require an internet connection from the device.
+
+### On SPIKE Legacy or MINDSTORMS Robot Inventor
+
+Use the installer script in mpy-robot-tools: <https://github.com/antonvh/mpy-robot-tools/blob/master/Installer/install_mpy_robot_tools.py>
+
+## Quick Start
+
+### Connect to a LEGO Hub
+
+```python
+from btbricks import BtHub
+
+# Create hub instance
+hub = BtHub()
+
+# Connect to a nearby hub
+hub.connect()
+
+if hub.is_connected():
+    # Set hub LED to green
+    hub.set_led_color(6)  # GREEN constant
+    
+    # Read accelerometer data
+    acc = hub.acc()
+    if acc:
+        print(f"Accelerometer: {acc}")
+    
+    # Control motor on port A with 50% power
+    hub.dc("A", 50)
+    
+    hub.disconnect()
+```
+
+### Create an RC Receiver (Hub-side)
+Use the examples in the `examples/` folder for full, runnable code. Minimal receiver/transmitter snippets:
+
+```python
+from btbricks import RCReceiver, R_STICK_HOR, R_STICK_VER
+from time import sleep_ms
+
+# Create RC receiver (advertises as "robot" by default)
+rcv = RCReceiver(name="robot")
+
+print("Waiting for RC transmitter to connect...")
+try:
+    while True:
+        if rcv.is_connected():
+            steering = rcv.controller_state(R_STICK_HOR)
+            throttle = rcv.controller_state(R_STICK_VER)
+            print(f"Steering: {steering}, Throttle: {throttle}")
+            sleep_ms(100)
+        else:
+            sleep_ms(500)
+except KeyboardInterrupt:
+    rcv.disconnect()
+```
+
+```python
+from btbricks import RCTransmitter, L_STICK_HOR, R_STICK_VER
+from time import sleep
+
+# Create RC transmitter (central)
+tx = RCTransmitter()
+
+if tx.connect(name="robot"):
+    try:
+        while tx.is_connected():
+            # Set stick values in range [-100, 100]
+            tx.set_stick(L_STICK_HOR, 0)
+            tx.set_stick(R_STICK_VER, 50)
+            tx.transmit()
+            sleep(0.1)
+    except KeyboardInterrupt:
+        tx.disconnect()
+```
+
+### Create a MIDI Controller
+
+```python
+from btbricks import MidiController
+from time import sleep
+
+# Create MIDI controller (advertises as "amh-midi" by default)
+midi = MidiController(name="amh-midi")
+
+print("MIDI controller started, connect from your DAW...")
+
+try:
+    while True:
+        # Send MIDI note on: middle C (note 60), velocity 100
+        midi.note_on(60, 100)
+        sleep(0.5)
+        
+        # Send MIDI note off
+        midi.note_off(60)
+        sleep(0.5)
+        
+        # Or send a chord
+        midi.chord_on("C4", velocity=100, style="M")  # C major chord
+        sleep(1)
+        midi.note_off(60)  # Stop the chord
+        
+except KeyboardInterrupt:
+    print("MIDI controller stopped")
+```
+
+## Documentation and API reference
+
+See the full documentation and API reference at:
+
+https://docs.antonsmindstorms.com/en/latest/Software/btbricks/docs/index.html
+
+### Core Classes
+
+- `BLEHandler`: Low-level Bluetooth communication
+- `UARTCentral`: Nordic UART client mode
+- `UARTPeripheral`: Nordic UART server mode
+- `RCReceiver`: Receive RC control signals
+- `RCTransmitter`: Send RC control signals
+- `MidiController`: Send MIDI commands over BLE
+- `BtHub`: High-level hub communication interface
+
+### Control Constants
+
+- Sticks: `L_STICK_HOR`, `L_STICK_VER`, `R_STICK_HOR`, `R_STICK_VER`
+- Triggers: `L_TRIGGER`, `R_TRIGGER`
+- Buttons: `BUTTONS`
+- Settings: `SETTING1`, `SETTING2`
+
+## Supported Platforms
+
+- **LEGO MINDSTORMS EV3** (with MicroPython firmware)
+- **LEGO SPIKE Prime/Prime Essential** (with MINDSTORMS firmware)
+- **LEGO SPIKE Robot Inventor**
+- **ESP32** with MicroPython
+- Other MicroPython boards with `ubluetooth` support
+
+
+## License
+
+MIT License
+
+## Author
+
+Anton Vanhoucke

btbricks-0.2.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+btbricks/__init__.py,sha256=U1Yxw-A51X4eGmuACmqdfRpb9v_CNs6sgTy4RBKMQZU,1051
+btbricks/bt.py,sha256=JLtXm3RsfpLTbWzGYhrEC1_AMlTpyXHaEoBR1Q5lC7A,44575
+btbricks/bthub.py,sha256=TVvpVo5E9nIzwmASMTAjjLs0lbY4Su4CYFlBU4KZ3dY,7967
+btbricks/ctrl_plus.py,sha256=CAnkG_SZ9Zysv4ZUDJ7UE0HTLMGeZYD0JxPEIIf-o6Y,177
+btbricks-0.2.1.dist-info/licenses/LICENSE,sha256=yVFkYtNY8Mlp5U_xedI4-O8Hxjg_vu-taxJlv8y-xVk,1078
+tests/__init__.py,sha256=CtJ2NCOCvkNNpVgAw3XHsKd_S-C36d7Yuq4QfTPmwgg,34
+tests/test_bthub.py,sha256=9yyBhsydjwN7_yXKzsKTEAxcjW_PqOzwZFcQ2dDv_f0,3298
+tests/test_constants.py,sha256=L0rIn8VsPIPc80qITblsPu9mQltL85pAFLQl2KQUpGY,2023
+tests/test_imports.py,sha256=kHrRnueFPnQxU807Bo9Ddr3x4hsryMroUoWC816N-Nc,2147
+btbricks-0.2.1.dist-info/METADATA,sha256=mdeew3CTC3HfEYMKbHW8AcN2jhrzep9Cf9rUMSE_WkY,7770
+btbricks-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+btbricks-0.2.1.dist-info/top_level.txt,sha256=nznVmPKoDx79OB6rEM180swD9X5G22V35afi5zon1d8,15
+btbricks-0.2.1.dist-info/RECORD,,

btbricks-0.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

btbricks-0.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 btbricks contributors
+
+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.

btbricks-0.2.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+btbricks
+tests

tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for btbricks package."""

tests/test_bthub.py

@@ -0,0 +1,102 @@
+"""Tests for BtHub class."""
+
+import pytest
+from unittest.mock import Mock, MagicMock, patch
+
+
+class TestBtHubInitialization:
+    """Test BtHub initialization."""
+
+    def test_bthub_init_default(self):
+        """Test BtHub initialization with default BLEHandler."""
+        from btbricks import BtHub
+
+        with patch("btbricks.bthub.BLEHandler"):
+            hub = BtHub()
+            assert hub._conn_handle is None
+            assert hub.acc_sub is False
+            assert hub.gyro_sub is False
+            assert hub.tilt_sub is False
+            assert isinstance(hub.hub_data, dict)
+            assert isinstance(hub.mode_info, dict)
+
+    def test_bthub_init_with_ble_handler(self):
+        """Test BtHub initialization with custom BLEHandler."""
+        from btbricks import BtHub
+
+        mock_ble = Mock()
+        hub = BtHub(ble_handler=mock_ble)
+        assert hub.ble_handler is mock_ble
+        assert hub._conn_handle is None
+
+    def test_bthub_is_connected_false(self):
+        """Test is_connected returns False when not connected."""
+        from btbricks import BtHub
+
+        with patch("btbricks.bthub.BLEHandler"):
+            hub = BtHub()
+            assert hub.is_connected() is False
+
+    def test_bthub_is_connected_true(self):
+        """Test is_connected returns True when connected."""
+        from btbricks import BtHub
+
+        with patch("btbricks.bthub.BLEHandler"):
+            hub = BtHub()
+            hub._conn_handle = 1
+            assert hub.is_connected() is True
+
+
+class TestBtHubColorConstants:
+    """Test BtHub LED color constants."""
+
+    def test_color_constants_exist(self):
+        """Test that color constants are defined."""
+        from btbricks.bthub import OFF, PINK, PURPLE, DARK_BLUE, BLUE, TEAL
+        from btbricks.bthub import GREEN, YELLOW, ORANGE, RED, WHITE
+
+        colors = [OFF, PINK, PURPLE, DARK_BLUE, BLUE, TEAL, GREEN, YELLOW, ORANGE, RED, WHITE]
+
+        # All should be integers
+        assert all(isinstance(c, int) for c in colors)
+
+        # All should be non-negative
+        assert all(c >= 0 for c in colors)
+
+
+class TestBtHubClampInt:
+    """Test clamp_int helper function."""
+
+    def test_clamp_int_within_range(self):
+        """Test clamp_int with value within range."""
+        from btbricks.bthub import clamp_int
+
+        assert clamp_int(50) == 50
+        assert clamp_int(0) == 0
+
+    def test_clamp_int_below_min(self):
+        """Test clamp_int with value below minimum."""
+        from btbricks.bthub import clamp_int
+
+        assert clamp_int(-150) == -100
+
+    def test_clamp_int_above_max(self):
+        """Test clamp_int with value above maximum."""
+        from btbricks.bthub import clamp_int
+
+        assert clamp_int(150) == 100
+
+    def test_clamp_int_custom_range(self):
+        """Test clamp_int with custom floor and ceiling."""
+        from btbricks.bthub import clamp_int
+
+        assert clamp_int(5, floor=0, ceiling=10) == 5
+        assert clamp_int(-5, floor=0, ceiling=10) == 0
+        assert clamp_int(15, floor=0, ceiling=10) == 10
+
+    def test_clamp_int_rounds(self):
+        """Test clamp_int rounds values."""
+        from btbricks.bthub import clamp_int
+
+        assert clamp_int(50.4) == 50
+        assert clamp_int(50.5) == 50 or clamp_int(50.5) == 51  # Banker's rounding

tests/test_constants.py

@@ -0,0 +1,77 @@
+"""Tests for btbricks constants."""
+
+import pytest
+
+
+class TestRCConstants:
+    """Test RC control constants."""
+
+    def test_stick_constants(self):
+        """Test that stick constants are defined correctly."""
+        from btbricks import (
+            L_STICK_HOR,
+            L_STICK_VER,
+            R_STICK_HOR,
+            R_STICK_VER,
+        )
+
+        assert L_STICK_HOR == 0
+        assert L_STICK_VER == 1
+        assert R_STICK_HOR == 2
+        assert R_STICK_VER == 3
+
+    def test_trigger_constants(self):
+        """Test that trigger constants are defined correctly."""
+        from btbricks import L_TRIGGER, R_TRIGGER
+
+        assert L_TRIGGER == 4
+        assert R_TRIGGER == 5
+
+    def test_button_and_setting_constants(self):
+        """Test button and setting constants."""
+        from btbricks import BUTTONS, SETTING1, SETTING2
+
+        assert BUTTONS == 8
+        assert SETTING1 == 6
+        assert SETTING2 == 7
+
+    def test_constants_are_unique(self):
+        """Test that all RC constants are unique."""
+        from btbricks import (
+            L_STICK_HOR,
+            L_STICK_VER,
+            R_STICK_HOR,
+            R_STICK_VER,
+            L_TRIGGER,
+            R_TRIGGER,
+            SETTING1,
+            SETTING2,
+            BUTTONS,
+        )
+
+        constants = [
+            L_STICK_HOR,
+            L_STICK_VER,
+            R_STICK_HOR,
+            R_STICK_VER,
+            L_TRIGGER,
+            R_TRIGGER,
+            SETTING1,
+            SETTING2,
+            BUTTONS,
+        ]
+
+        assert len(constants) == len(set(constants))
+
+
+class TestPortConstants:
+    """Test port mapping constants in BtHub."""
+
+    def test_port_mapping(self):
+        """Test that BtHub has correct port mapping."""
+        from btbricks import BtHub
+
+        with __import__("unittest.mock").mock.patch("btbricks.bthub.BLEHandler"):
+            hub = BtHub()
+            # Check that _BtHub__PORTS exists (name-mangled private attribute)
+            assert hasattr(hub, "_BtHub__PORTS")