swbt-python 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

swbt/gamepad/output.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass, field
 
 from swbt.diagnostics import DiagnosticsRecorder
 from swbt.protocol.output_report import OutputReportParser
+from swbt.protocol.session import SwitchHidSession
 from swbt.protocol.subcommand import (
     SESSION_STATE_SUBCOMMANDS,
     SubcommandResponder,
@@ -12,7 +13,8 @@ from swbt.protocol.subcommand import (
 )
 from swbt.state_store import InputStateStore
 
-ReplySender = Callable[[bytes], Awaitable[None]]
+ReplyBuilder = Callable[[], bytes]
+ReplySender = Callable[[ReplyBuilder], Awaitable[bytes]]
 ReplySenderRequirement = Callable[[], None]
 
 
@@ -23,6 +25,7 @@ class OutputReportDispatcher:
     diagnostics: DiagnosticsRecorder
     require_reply_sender: ReplySenderRequirement
     send_subcommand_reply: ReplySender
+    session: SwitchHidSession
     state_store: InputStateStore
     output_report_parser: OutputReportParser = field(default_factory=OutputReportParser)
     subcommand_responder: SubcommandResponder = field(default_factory=SubcommandResponder)
@@ -49,7 +52,13 @@ class OutputReportDispatcher:
         self.require_reply_sender()
         state = await self.state_store.snapshot()
         try:
-            reply = self.subcommand_responder.respond(output_report, state=state)
+            reply = await self.send_subcommand_reply(
+                lambda: self.subcommand_responder.respond(
+                    output_report,
+                    state=state,
+                    session=self.session,
+                )
+            )
         except UnsupportedSubcommandError:
             self.diagnostics.record_event(
                 "unsupported_subcommand",
@@ -59,10 +68,11 @@ class OutputReportDispatcher:
             )
             raise
         if output_report.subcommand_id in SESSION_STATE_SUBCOMMANDS:
-            session_state = self.subcommand_responder.session_state
+            session_state = self.session.state
             self.diagnostics.record_event(
                 "subcommand_session_state",
                 imu_enabled=session_state.imu_enabled,
+                imu_encoding_format=session_state.imu_encoding_format,
                 imu_mode=_format_optional_byte(session_state.imu_mode),
                 packet_id=output_report.packet_id,
                 report_mode=_format_optional_byte(session_state.report_mode),
@@ -79,7 +89,6 @@ class OutputReportDispatcher:
             report_id=_format_report_id(reply[0]),
             subcommand_id=subcommand_id,
         )
-        await self.send_subcommand_reply(reply)
 
 
 def _format_report_id(report_id: int) -> str:

swbt/gamepad/runtime.py

@@ -1,6 +1,7 @@
 """Stateful runtime for gamepad lifecycle and input behavior."""
 
 import asyncio
+from collections.abc import Callable
 from dataclasses import replace
 from types import TracebackType
 
@@ -26,6 +27,7 @@ from swbt.gamepad.transport_factory import (
 from swbt.input import Button, IMUFrame, InputState, Stick
 from swbt.protocol.input_report import InputReportBuilder
 from swbt.protocol.profiles.base import ControllerColors
+from swbt.protocol.session import SwitchHidSession
 from swbt.protocol.subcommand import SubcommandResponder
 from swbt.report_loop import ReportLoop
 from swbt.state_store import InputStateStore
@@ -103,12 +105,16 @@ class ControllerRuntime:
             controller_colors=self._config.controller_colors
             or self._config.profile.controller_colors,
         )
+        self._protocol_session = SwitchHidSession(self._controller_profile)
         self._output_report_dispatcher = OutputReportDispatcher(
             diagnostics=self._diagnostics,
             require_reply_sender=self._require_subcommand_reply_sender,
             send_subcommand_reply=self._send_subcommand_reply,
+            session=self._protocol_session,
             state_store=self._state_store,
-            subcommand_responder=SubcommandResponder(profile=self._controller_profile),
+            subcommand_responder=SubcommandResponder(
+                profile=self._controller_profile,
+            ),
         )
         self._report_loop: ReportLoop | None = None
         self._lifecycle_lock = asyncio.Lock()
@@ -198,6 +204,7 @@ class ControllerRuntime:
             transport = self._ensure_transport()
             self._record_run_metadata()
             self._connection_state = "opening"
+            self._reset_protocol_session()
             self._register_transport_callbacks()
             self._connected_event.clear()
             try:
@@ -207,7 +214,10 @@ class ControllerRuntime:
                     transport=transport,
                     state_store=self._state_store,
                     report_period_us=self._config.report_period_us,
-                    input_report_builder=InputReportBuilder(self._controller_profile),
+                    input_report_builder=InputReportBuilder(
+                        self._controller_profile,
+                    ),
+                    session=self._protocol_session,
                     diagnostics=self._diagnostics,
                 )
                 self._connection_state = "opened"
@@ -219,6 +229,15 @@ class ControllerRuntime:
                 self._is_open = False
                 raise
 
+    def _reset_protocol_session(self) -> None:
+        """Create fresh host-requested state for the next HID connection."""
+        self._protocol_session = SwitchHidSession(self._controller_profile)
+        self._output_report_dispatcher.session = self._protocol_session
+        self._output_report_dispatcher.subcommand_responder = SubcommandResponder(
+            profile=self._controller_profile,
+        )
+        self._configured_device_info_bluetooth_address = None
+
     async def pair(self, timeout: float | None = None) -> None:  # noqa: ASYNC109
         """Start pairing advertising and wait for a host connection.
 
@@ -583,8 +602,8 @@ class ControllerRuntime:
     def _require_subcommand_reply_sender(self) -> None:
         _ = self._subcommand_reply_sender()
 
-    async def _send_subcommand_reply(self, reply: bytes) -> None:
-        await self._subcommand_reply_sender().send_subcommand_reply(reply)
+    async def _send_subcommand_reply(self, build_reply: Callable[[], bytes]) -> bytes:
+        return await self._subcommand_reply_sender().send_subcommand_reply(build_reply)
 
     def _subcommand_reply_sender(self) -> ReportLoop:
         if self._report_loop is None:

swbt/imu.py

@@ -0,0 +1,116 @@
+"""Shared virtual IMU calibration values."""
+
+from dataclasses import dataclass
+from math import degrees, isfinite, radians
+from struct import pack
+
+from swbt.errors import InvalidInputError
+
+
+@dataclass(frozen=True)
+class _ThreeAxisCalibration:
+    """Shared XYZ zero/reference model for factory sensor calibration."""
+
+    zero_raw: tuple[int, int, int] = (0, 0, 0)
+    reference_raw: tuple[int, int, int] = (0, 0, 0)
+
+    def to_spi_bytes(self) -> bytes:
+        """Return zero XYZ followed by reference XYZ as signed Int16LE."""
+        return pack("<6h", *self.zero_raw, *self.reference_raw)
+
+
+@dataclass(frozen=True)
+class AccelerometerCalibration(_ThreeAxisCalibration):
+    """Virtual accelerometer calibration and fixed conversion scale."""
+
+    reference_raw: tuple[int, int, int] = (0x4000, 0x4000, 0x4000)
+
+    @property
+    def reference_acceleration_g(self) -> float:
+        """Return the fixed reference acceleration in G."""
+        return 4.0
+
+    @property
+    def g_per_raw(self) -> float:
+        """Return the fixed accelerometer sensitivity in G per raw unit."""
+        return 1 / 4096
+
+    def accelerations_to_raw(
+        self,
+        accelerations_g: tuple[float, float, float],
+    ) -> tuple[int, int, int]:
+        """Convert XYZ accelerations in G to raw values."""
+        values = tuple(
+            self._validate_acceleration(f"{axis}_g", value)
+            for axis, value in zip("xyz", accelerations_g, strict=True)
+        )
+        converted = tuple(
+            zero + round(value / self.g_per_raw)
+            for zero, value in zip(self.zero_raw, values, strict=True)
+        )
+        return (converted[0], converted[1], converted[2])
+
+    def raw_to_accelerations(
+        self,
+        raw: tuple[int, int, int],
+    ) -> tuple[float, float, float]:
+        """Convert XYZ raw values to accelerations in G."""
+        converted = tuple(
+            (value - zero) * self.g_per_raw for zero, value in zip(self.zero_raw, raw, strict=True)
+        )
+        return (converted[0], converted[1], converted[2])
+
+    @staticmethod
+    def _validate_acceleration(name: str, value: object) -> float:
+        if not isinstance(value, (int, float)) or isinstance(value, bool) or not isfinite(value):
+            msg = f"{name} must be a finite number: {value}"
+            raise InvalidInputError(msg)
+        return float(value)
+
+
+@dataclass(frozen=True)
+class GyroCalibration(_ThreeAxisCalibration):
+    """Virtual gyroscope zero, reference, and fixed conversion scale."""
+
+    reference_raw: tuple[int, int, int] = (0x343B, 0x343B, 0x343B)
+
+    @property
+    def dps_per_raw(self) -> float:
+        """Return the fixed gyroscope sensitivity in degrees per second per raw unit."""
+        return 0.070
+
+    def gyro_rates_to_raw(
+        self,
+        rates_rad_s: tuple[float, float, float],
+    ) -> tuple[int, int, int]:
+        """Convert XYZ angular velocities in radians per second to raw values."""
+        x_rad_s = self._validate_rate("x_rad_s", rates_rad_s[0])
+        y_rad_s = self._validate_rate("y_rad_s", rates_rad_s[1])
+        z_rad_s = self._validate_rate("z_rad_s", rates_rad_s[2])
+        return (
+            self.zero_raw[0] + round(degrees(x_rad_s) / self.dps_per_raw),
+            self.zero_raw[1] + round(degrees(y_rad_s) / self.dps_per_raw),
+            self.zero_raw[2] + round(degrees(z_rad_s) / self.dps_per_raw),
+        )
+
+    def raw_to_gyro_rates(
+        self,
+        raw: tuple[int, int, int],
+    ) -> tuple[float, float, float]:
+        """Convert XYZ raw values to angular velocities in radians per second."""
+        return (
+            radians((raw[0] - self.zero_raw[0]) * self.dps_per_raw),
+            radians((raw[1] - self.zero_raw[1]) * self.dps_per_raw),
+            radians((raw[2] - self.zero_raw[2]) * self.dps_per_raw),
+        )
+
+    @staticmethod
+    def _validate_rate(name: str, value: object) -> float:
+        if not isinstance(value, (int, float)) or isinstance(value, bool) or not isfinite(value):
+            msg = f"{name} must be a finite number: {value}"
+            raise InvalidInputError(msg)
+        return float(value)
+
+
+DEFAULT_ACCELEROMETER_CALIBRATION = AccelerometerCalibration()
+DEFAULT_GYRO_CALIBRATION = GyroCalibration()

swbt/input.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass
 from enum import Enum, auto
 
 from swbt.errors import InvalidInputError
+from swbt.imu import DEFAULT_ACCELEROMETER_CALIBRATION, DEFAULT_GYRO_CALIBRATION
 
 
 class Button(Enum):
@@ -309,6 +310,42 @@ class IMUFrame:
         """
         return cls.raw(gyro=(x, y, z))
 
+    @classmethod
+    def gyro_rate(
+        cls,
+        *,
+        x_rad_s: float = 0.0,
+        y_rad_s: float = 0.0,
+        z_rad_s: float = 0.0,
+    ) -> "IMUFrame":
+        """Return a frame from XYZ gyroscope rates in radians per second.
+
+        Conversion uses the fixed virtual sensitivity of ``0.070 dps/raw``.
+
+        Args:
+            x_rad_s: X-axis angular velocity in radians per second.
+            y_rad_s: Y-axis angular velocity in radians per second.
+            z_rad_s: Z-axis angular velocity in radians per second.
+
+        Returns:
+            IMUFrame: Frame with converted gyroscope raw values and zero accelerometer.
+
+        Raises:
+            InvalidInputError: A converted raw value is outside the signed 16-bit range.
+        """
+        return cls.raw(gyro=DEFAULT_GYRO_CALIBRATION.gyro_rates_to_raw((x_rad_s, y_rad_s, z_rad_s)))
+
+    def to_gyro_rate(self) -> tuple[float, float, float]:
+        """Return XYZ gyroscope rates in radians per second.
+
+        Conversion uses the fixed virtual sensitivity of ``0.070 dps/raw``.
+
+        Returns:
+            tuple[float, float, float]: X, Y, and Z angular velocities in radians per
+                second.
+        """
+        return DEFAULT_GYRO_CALIBRATION.raw_to_gyro_rates((self.gyro_x, self.gyro_y, self.gyro_z))
+
     @classmethod
     def accel(cls, x: int = 0, y: int = 0, z: int = 0) -> "IMUFrame":
         """Return an IMU frame with only accelerometer axes set.
@@ -326,6 +363,41 @@ class IMUFrame:
         """
         return cls.raw(accel=(x, y, z))
 
+    @classmethod
+    def accel_g(
+        cls,
+        *,
+        x_g: float = 0.0,
+        y_g: float = 0.0,
+        z_g: float = 0.0,
+    ) -> "IMUFrame":
+        """Return a frame from XYZ accelerations in G using ``1/4096 G/raw``.
+
+        Args:
+            x_g: X-axis acceleration in G.
+            y_g: Y-axis acceleration in G.
+            z_g: Z-axis acceleration in G.
+
+        Returns:
+            IMUFrame: Frame with converted accelerometer raw values and zero gyroscope.
+
+        Raises:
+            InvalidInputError: A value is non-finite or converts outside signed 16-bit.
+        """
+        return cls.raw(
+            accel=DEFAULT_ACCELEROMETER_CALIBRATION.accelerations_to_raw((x_g, y_g, z_g))
+        )
+
+    def to_accel_g(self) -> tuple[float, float, float]:
+        """Return XYZ accelerations in G using ``1/4096 G/raw``.
+
+        Returns:
+            tuple[float, float, float]: X, Y, and Z accelerations in G.
+        """
+        return DEFAULT_ACCELEROMETER_CALIBRATION.raw_to_accelerations(
+            (self.accel_x, self.accel_y, self.accel_z)
+        )
+
     def with_gyro(self, x: int = 0, y: int = 0, z: int = 0) -> "IMUFrame":
         """Return a frame with replaced gyroscope axes.
 
@@ -345,6 +417,32 @@ class IMUFrame:
             gyro=(x, y, z),
         )
 
+    def with_gyro_rate(
+        self,
+        *,
+        x_rad_s: float = 0.0,
+        y_rad_s: float = 0.0,
+        z_rad_s: float = 0.0,
+    ) -> "IMUFrame":
+        """Return a frame with gyroscope rates replaced from radians per second.
+
+        Conversion uses the fixed virtual sensitivity of ``0.070 dps/raw``.
+
+        Args:
+            x_rad_s: Replacement X-axis angular velocity in radians per second.
+            y_rad_s: Replacement Y-axis angular velocity in radians per second.
+            z_rad_s: Replacement Z-axis angular velocity in radians per second.
+
+        Returns:
+            IMUFrame: Copy of this frame with accelerometer axes preserved.
+
+        Raises:
+            InvalidInputError: A converted raw value is outside the signed 16-bit range.
+        """
+        return self.with_gyro(
+            *DEFAULT_GYRO_CALIBRATION.gyro_rates_to_raw((x_rad_s, y_rad_s, z_rad_s))
+        )
+
     def with_accel(self, x: int = 0, y: int = 0, z: int = 0) -> "IMUFrame":
         """Return a frame with replaced accelerometer axes.
 
@@ -364,6 +462,30 @@ class IMUFrame:
             gyro=(self.gyro_x, self.gyro_y, self.gyro_z),
         )
 
+    def with_accel_g(
+        self,
+        *,
+        x_g: float = 0.0,
+        y_g: float = 0.0,
+        z_g: float = 0.0,
+    ) -> "IMUFrame":
+        """Return a frame with accelerations replaced using ``1/4096 G/raw``.
+
+        Args:
+            x_g: Replacement X-axis acceleration in G.
+            y_g: Replacement Y-axis acceleration in G.
+            z_g: Replacement Z-axis acceleration in G.
+
+        Returns:
+            IMUFrame: Copy of this frame with gyroscope axes preserved.
+
+        Raises:
+            InvalidInputError: A value is non-finite or converts outside signed 16-bit.
+        """
+        return self.with_accel(
+            *DEFAULT_ACCELEROMETER_CALIBRATION.accelerations_to_raw((x_g, y_g, z_g))
+        )
+
     @classmethod
     def _validate_i16(cls, field_name: str, value: object) -> int:
         if not isinstance(value, int) or not cls.MIN <= value <= cls.MAX:

swbt/protocol/imu_report.py

@@ -0,0 +1,186 @@
+"""Pure IMU wire encoding from explicit state and report time."""
+
+from dataclasses import dataclass
+from enum import IntEnum
+from math import cos, sin, sqrt
+from struct import pack_into
+
+from swbt.imu import GyroCalibration
+from swbt.input import IMUFrame
+
+_Quaternion = tuple[float, float, float, float]
+_IDENTITY_QUATERNION: _Quaternion = (0.0, 0.0, 0.0, 1.0)
+
+
+class ImuMode(IntEnum):
+    """Host-selected IMU wire mode."""
+
+    DISABLED = 0x00
+    STANDARD = 0x01
+    QUATERNION_1 = 0x02
+    QUATERNION_2 = 0x03
+    QUATERNION_3 = 0x04
+    QUATERNION_4 = 0x05
+
+
+@dataclass(frozen=True)
+class ImuEncodingState:
+    """State required to encode the next quaternion IMU block."""
+
+    orientation: _Quaternion = _IDENTITY_QUATERNION
+    previous_report_ns: int | None = None
+
+
+@dataclass(frozen=True)
+class ImuEncodingResult:
+    """One encoded IMU block and the state for the next report."""
+
+    block: bytes
+    state: ImuEncodingState
+
+
+def encode_disabled_imu() -> ImuEncodingResult:
+    """Encode the disabled IMU block and reset its encoding state."""
+    return ImuEncodingResult(block=bytes(36), state=ImuEncodingState())
+
+
+def encode_imu_block(
+    *,
+    state: ImuEncodingState,
+    mode: ImuMode,
+    frames: tuple[IMUFrame, IMUFrame, IMUFrame],
+    gyro_calibration: GyroCalibration,
+    now_ns: int,
+) -> ImuEncodingResult:
+    """Encode one IMU block for the explicit host-selected mode."""
+    if mode is ImuMode.DISABLED:
+        return encode_disabled_imu()
+    if mode is ImuMode.STANDARD:
+        return ImuEncodingResult(
+            block=encode_standard_imu(frames),
+            state=ImuEncodingState(),
+        )
+    return encode_quaternion_imu(
+        state=state,
+        frames=frames,
+        gyro_calibration=gyro_calibration,
+        now_ns=now_ns,
+    )
+
+
+def encode_standard_imu(frames: tuple[IMUFrame, IMUFrame, IMUFrame]) -> bytes:
+    """Encode three raw six-axis frames as signed Int16LE values."""
+    result = bytearray(36)
+    for offset, frame in zip((0, 12, 24), frames, strict=True):
+        pack_into(
+            "<6h",
+            result,
+            offset,
+            frame.accel_x,
+            frame.accel_y,
+            frame.accel_z,
+            frame.gyro_x,
+            frame.gyro_y,
+            frame.gyro_z,
+        )
+    return bytes(result)
+
+
+def encode_quaternion_imu(
+    *,
+    state: ImuEncodingState,
+    frames: tuple[IMUFrame, IMUFrame, IMUFrame],
+    gyro_calibration: GyroCalibration,
+    now_ns: int,
+) -> ImuEncodingResult:
+    """Encode one 36-byte packing-mode-2 block without mutating inputs."""
+    elapsed_seconds = 0.0
+    if state.previous_report_ns is not None:
+        elapsed_seconds = max(0, now_ns - state.previous_report_ns) / 1_000_000_000
+
+    orientation = state.orientation
+    sample_seconds = elapsed_seconds / len(frames)
+    for frame in frames:
+        rates = gyro_calibration.raw_to_gyro_rates((frame.gyro_x, frame.gyro_y, frame.gyro_z))
+        orientation = _next_orientation(orientation, rates, sample_seconds)
+
+    next_state = ImuEncodingState(
+        orientation=orientation,
+        previous_report_ns=now_ns,
+    )
+    return ImuEncodingResult(
+        block=_pack_mode_2(frames, orientation, timestamp_ms=now_ns // 1_000_000),
+        state=next_state,
+    )
+
+
+def _next_orientation(
+    orientation: _Quaternion,
+    rates_rad_s: tuple[float, float, float],
+    elapsed_seconds: float,
+) -> _Quaternion:
+    rotation = tuple(rate * elapsed_seconds for rate in rates_rad_s)
+    magnitude = sqrt(sum(value * value for value in rotation))
+    if magnitude == 0:
+        return orientation
+    half_angle = magnitude / 2
+    vector_scale = sin(half_angle) / magnitude
+    delta = (
+        rotation[0] * vector_scale,
+        rotation[1] * vector_scale,
+        rotation[2] * vector_scale,
+        cos(half_angle),
+    )
+    return _normalize(_hamilton_product(orientation, delta))
+
+
+def _hamilton_product(left: _Quaternion, right: _Quaternion) -> _Quaternion:
+    lx, ly, lz, lw = left
+    rx, ry, rz, rw = right
+    return (
+        lw * rx + lx * rw + ly * rz - lz * ry,
+        lw * ry + ly * rw + lz * rx - lx * rz,
+        lw * rz + lz * rw + lx * ry - ly * rx,
+        lw * rw - lx * rx - ly * ry - lz * rz,
+    )
+
+
+def _normalize(value: _Quaternion) -> _Quaternion:
+    inverse = 1 / sqrt(sum(component * component for component in value))
+    return (value[0] * inverse, value[1] * inverse, value[2] * inverse, value[3] * inverse)
+
+
+def _pack_mode_2(
+    frames: tuple[IMUFrame, IMUFrame, IMUFrame],
+    orientation: _Quaternion,
+    *,
+    timestamp_ms: int,
+) -> bytes:
+    result = bytearray(36)
+    for offset, frame in zip((0, 12, 24), frames, strict=True):
+        pack_into("<3h", result, offset, frame.accel_x, frame.accel_y, frame.accel_z)
+
+    max_index = max(range(4), key=lambda index: abs(orientation[index]))
+    sign = -1 if orientation[max_index] < 0 else 1
+    components = [
+        int(orientation[(max_index + index + 1) & 3] * sign * 0x40000000) >> 10
+        for index in range(3)
+    ]
+
+    _put_bits(result, 48, 2, 2)
+    _put_bits(result, 50, 2, max_index)
+    _put_bits(result, 52, 21, components[0])
+    _put_bits(result, 73, 21, components[1])
+    _put_bits(result, 94, 2, components[2])
+    _put_bits(result, 144, 19, components[2] >> 2)
+    _put_bits(result, 271, 11, timestamp_ms)
+    _put_bits(result, 282, 6, 3)
+    return bytes(result)
+
+
+def _put_bits(target: bytearray, start: int, width: int, value: int) -> None:
+    masked = value & ((1 << width) - 1)
+    for bit in range(width):
+        if masked & (1 << bit):
+            absolute = start + bit
+            target[absolute // 8] |= 1 << (absolute % 8)

swbt/protocol/input_report.py

@@ -1,6 +1,7 @@
 """Input report builders."""
 
 from swbt.input import InputState, Stick
+from swbt.protocol.imu_report import encode_standard_imu
 from swbt.protocol.profiles.base import ControllerProfile
 from swbt.protocol.profiles.pro_controller import default_controller_profile
 
@@ -8,11 +9,20 @@ from swbt.protocol.profiles.pro_controller import default_controller_profile
 class InputReportBuilder:
     """Build Switch HID input reports from immutable input state."""
 
-    def __init__(self, profile: ControllerProfile | None = None) -> None:
+    def __init__(
+        self,
+        profile: ControllerProfile | None = None,
+    ) -> None:
         """Create a report builder."""
         self._profile = profile or default_controller_profile()
 
-    def build_0x30(self, state: InputState, *, timer: int = 0) -> bytes:
+    def build_0x30(
+        self,
+        state: InputState,
+        *,
+        timer: int = 0,
+        imu_block: bytes | None = None,
+    ) -> bytes:
         """Build a 0x30 standard full input report."""
         self._profile.validate_input_state(state)
         report = bytearray(49)
@@ -23,9 +33,17 @@ class InputReportBuilder:
         report[6:9] = self._pack_stick(state.left_stick)
         report[9:12] = self._pack_stick(state.right_stick)
         report[12] = self._profile.vibrator_input
-        self._pack_imu_frames(report, state)
+        block = encode_standard_imu(state.imu_frames) if imu_block is None else imu_block
+        self._place_imu_block(report, block)
         return bytes(report)
 
+    @staticmethod
+    def _place_imu_block(report: bytearray, imu_block: bytes) -> None:
+        if len(imu_block) != 36:
+            msg = f"IMU block must be 36 bytes, got {len(imu_block)}"
+            raise ValueError(msg)
+        report[13:49] = imu_block
+
     def _pack_buttons(self, report: bytearray, state: InputState) -> None:
         for button in state.buttons:
             offset, mask = self._profile.button_bit(button)
@@ -40,18 +58,3 @@ class InputReportBuilder:
                 (stick.y >> 4) & 0xFF,
             )
         )
-
-    @staticmethod
-    def _pack_imu_frames(report: bytearray, state: InputState) -> None:
-        cursor = 13
-        for frame in state.imu_frames:
-            for value in (
-                frame.accel_x,
-                frame.accel_y,
-                frame.accel_z,
-                frame.gyro_x,
-                frame.gyro_y,
-                frame.gyro_z,
-            ):
-                report[cursor : cursor + 2] = int(value).to_bytes(2, "little", signed=True)
-                cursor += 2

swbt/protocol/profiles/base.py

@@ -4,6 +4,12 @@ from dataclasses import dataclass, field
 from enum import Enum
 
 from swbt.errors import InvalidInputError, UnsupportedInputError
+from swbt.imu import (
+    DEFAULT_ACCELEROMETER_CALIBRATION,
+    DEFAULT_GYRO_CALIBRATION,
+    AccelerometerCalibration,
+    GyroCalibration,
+)
 from swbt.input import Button, InputState, Stick
 from swbt.protocol.buttons import PRO_CONTROLLER_BUTTON_BITS, ButtonBitMap
 from swbt.protocol.descriptors import SWITCH_PRO_CONTROLLER_HID_REPORT_DESCRIPTOR
@@ -126,6 +132,8 @@ class ControllerProfile:
     hid_report_descriptor: bytes = SWITCH_PRO_CONTROLLER_HID_REPORT_DESCRIPTOR
     hid_sdp_policy: HidSdpPolicy = field(default_factory=HidSdpPolicy)
     controller_colors: ControllerColors = field(default_factory=ControllerColors)
+    accelerometer_calibration: AccelerometerCalibration = DEFAULT_ACCELEROMETER_CALIBRATION
+    gyro_calibration: GyroCalibration = DEFAULT_GYRO_CALIBRATION
     button_bits: ButtonBitMap = field(default_factory=lambda: PRO_CONTROLLER_BUTTON_BITS)
     imu_enable_modes: tuple[int, ...] = (0x00, 0x01)
     supports_left_stick: bool = True

swbt/protocol/profiles/joycon.py

@@ -14,7 +14,7 @@ from swbt.protocol.profiles.base import (
     HidSdpPolicy,
 )
 
-_JOYCON_IMU_ENABLE_MODE = 0x02
+_JOYCON_IMU_ENABLE_MODES = (0x00, 0x01, 0x02, 0x03, 0x04, 0x05)
 
 
 def _joycontrol_hid_sdp_policy() -> HidSdpPolicy:
@@ -63,7 +63,7 @@ class JoyConLeftProfile(ControllerProfile):
     hid_sdp_policy: HidSdpPolicy = field(default_factory=_joycontrol_hid_sdp_policy)
     controller_colors: ControllerColors = field(default_factory=_joycon_left_controller_colors)
     button_bits: ButtonBitMap = field(default_factory=lambda: JOYCON_LEFT_BUTTON_BITS)
-    imu_enable_modes: tuple[int, ...] = (0x00, 0x01, _JOYCON_IMU_ENABLE_MODE)
+    imu_enable_modes: tuple[int, ...] = _JOYCON_IMU_ENABLE_MODES
     supports_left_stick: bool = True
     supports_right_stick: bool = False
 
@@ -79,6 +79,6 @@ class JoyConRightProfile(ControllerProfile):
     hid_sdp_policy: HidSdpPolicy = field(default_factory=_joycontrol_hid_sdp_policy)
     controller_colors: ControllerColors = field(default_factory=_joycon_right_controller_colors)
     button_bits: ButtonBitMap = field(default_factory=lambda: JOYCON_RIGHT_BUTTON_BITS)
-    imu_enable_modes: tuple[int, ...] = (0x00, 0x01, _JOYCON_IMU_ENABLE_MODE)
+    imu_enable_modes: tuple[int, ...] = _JOYCON_IMU_ENABLE_MODES
     supports_left_stick: bool = False
     supports_right_stick: bool = True

swbt/protocol/profiles/pro_controller.py

@@ -15,7 +15,7 @@ class ProControllerProfile(ControllerProfile):
     device_type: int = 0x03
     device_info_tail: bytes = b"\x03\x02"
     button_bits: ButtonBitMap = field(default_factory=lambda: PRO_CONTROLLER_BUTTON_BITS)
-    imu_enable_modes: tuple[int, ...] = (0x00, 0x01, 0x02)
+    imu_enable_modes: tuple[int, ...] = (0x00, 0x01, 0x02, 0x03, 0x04, 0x05)
     supports_left_stick: bool = True
     supports_right_stick: bool = True
 

swbt/protocol/session.py

@@ -0,0 +1,112 @@
+"""Connection-scoped Switch HID protocol state."""
+
+from dataclasses import dataclass, field, replace
+
+from swbt.errors import ProtocolError
+from swbt.input import IMUFrame
+from swbt.protocol.imu_report import (
+    ImuEncodingState,
+    ImuMode,
+    encode_imu_block,
+)
+from swbt.protocol.profiles.base import ControllerProfile
+
+
+@dataclass(frozen=True)
+class SwitchHidSessionState:
+    """Immutable host-requested state for one HID connection."""
+
+    report_mode: int | None = None
+    report_mode_supported: bool = False
+    unsupported_report_mode: int | None = None
+    imu_mode: ImuMode = ImuMode.DISABLED
+    imu_encoding_state: ImuEncodingState = field(default_factory=ImuEncodingState)
+    vibration_enabled: bool = False
+
+    @property
+    def imu_enabled(self) -> bool:
+        """Return whether the host selected an active IMU mode."""
+        return self.imu_mode is not ImuMode.DISABLED
+
+    @property
+    def imu_encoding_format(self) -> str:
+        """Return the diagnostic wire-format name derived from the IMU mode."""
+        if self.imu_mode is ImuMode.DISABLED:
+            return "disabled"
+        if self.imu_mode is ImuMode.STANDARD:
+            return "standard"
+        return "quaternion"
+
+
+def apply_imu_mode_request(
+    state: SwitchHidSessionState,
+    *,
+    requested_mode: int,
+    accepted_modes: tuple[int, ...],
+) -> SwitchHidSessionState:
+    """Return the session state for a newly accepted IMU encoding epoch."""
+    if requested_mode not in accepted_modes:
+        msg = f"unsupported enable IMU value: 0x{requested_mode:02x}"
+        raise ProtocolError(msg)
+    try:
+        mode = ImuMode(requested_mode)
+    except ValueError as error:
+        msg = f"unknown enable IMU value: 0x{requested_mode:02x}"
+        raise ProtocolError(msg) from error
+    return replace(
+        state,
+        imu_mode=mode,
+        imu_encoding_state=ImuEncodingState(),
+    )
+
+
+class SwitchHidSession:
+    """Own host-requested and IMU encoding state for one HID connection."""
+
+    def __init__(self, profile: ControllerProfile) -> None:
+        """Create a disabled session for the configured controller profile."""
+        self._profile = profile
+        self._state = SwitchHidSessionState()
+
+    @property
+    def state(self) -> SwitchHidSessionState:
+        """Return the current immutable session state."""
+        return self._state
+
+    def set_report_mode(self, mode: int, *, supported: bool) -> None:
+        """Record one host-selected input report mode."""
+        self._state = replace(
+            self._state,
+            report_mode=mode,
+            report_mode_supported=supported,
+            unsupported_report_mode=None if supported else mode,
+        )
+
+    def set_imu_mode(self, mode: int) -> None:
+        """Start a new IMU encoding epoch for an accepted host mode."""
+        self._state = apply_imu_mode_request(
+            self._state,
+            requested_mode=mode,
+            accepted_modes=self._profile.imu_enable_modes,
+        )
+
+    def set_vibration_enabled(self, enabled: bool) -> None:
+        """Record the host-selected vibration enable state."""
+        self._state = replace(self._state, vibration_enabled=enabled)
+
+    def encode_imu(
+        self,
+        frames: tuple[IMUFrame, IMUFrame, IMUFrame],
+        *,
+        now_ns: int,
+    ) -> bytes:
+        """Encode one IMU block and retain only its explicit next state."""
+        result = encode_imu_block(
+            state=self._state.imu_encoding_state,
+            mode=self._state.imu_mode,
+            frames=frames,
+            gyro_calibration=self._profile.gyro_calibration,
+            now_ns=now_ns,
+        )
+        self._state = replace(self._state, imu_encoding_state=result.state)
+        return result.block

swbt/protocol/spi.py

@@ -16,6 +16,8 @@ class VirtualSpiFlash:
     COLOR_INFO_EXISTS_ADDRESS = 0x601B
     COLOR_INFO_EXISTS = 0x01
     CONTROLLER_COLORS_ADDRESS = 0x6050
+    FACTORY_ACCELEROMETER_CALIBRATION_ADDRESS = 0x6020
+    FACTORY_GYRO_CALIBRATION_ADDRESS = 0x602C
 
     def __init__(self, *, profile: ControllerProfile | None = None) -> None:
         """Create a virtual SPI flash image."""
@@ -27,6 +29,16 @@ class VirtualSpiFlash:
         self._data[
             self.CONTROLLER_COLORS_ADDRESS : self.CONTROLLER_COLORS_ADDRESS + len(controller_colors)
         ] = controller_colors
+        accelerometer_calibration = profile.accelerometer_calibration.to_spi_bytes()
+        accelerometer_address = self.FACTORY_ACCELEROMETER_CALIBRATION_ADDRESS
+        self._data[
+            accelerometer_address : accelerometer_address + len(accelerometer_calibration)
+        ] = accelerometer_calibration
+        gyro_calibration = profile.gyro_calibration.to_spi_bytes()
+        self._data[
+            self.FACTORY_GYRO_CALIBRATION_ADDRESS : self.FACTORY_GYRO_CALIBRATION_ADDRESS
+            + len(gyro_calibration)
+        ] = gyro_calibration
 
     def read(self, address: int, size: int) -> bytes:
         """Read bytes from the virtual SPI address space."""

swbt/protocol/subcommand.py

@@ -1,13 +1,12 @@
 """Subcommand reply generation."""
 
-from dataclasses import dataclass
-
 from swbt.errors import ProtocolError
 from swbt.input import InputState
 from swbt.protocol.input_report import InputReportBuilder
 from swbt.protocol.output_report import OutputReport
 from swbt.protocol.profiles.base import ControllerProfile
 from swbt.protocol.profiles.pro_controller import default_controller_profile
+from swbt.protocol.session import SwitchHidSession
 from swbt.protocol.spi import VirtualSpiFlash
 
 SIMPLE_ACK_SUBCOMMANDS = {0x08, 0x30}
@@ -21,18 +20,6 @@ MCU_CONFIG_DATA = bytes.fromhex(
 )
 
 
-@dataclass
-class SubcommandSessionState:
-    """Mutable host-requested subcommand state for one responder lifetime."""
-
-    report_mode: int | None = None
-    report_mode_supported: bool = False
-    unsupported_report_mode: int | None = None
-    imu_mode: int | None = None
-    imu_enabled: bool = False
-    vibration_enabled: bool = False
-
-
 class UnsupportedSubcommandError(ProtocolError):
     """Raised when a subcommand is not supported by the responder."""
 
@@ -51,22 +38,13 @@ class SubcommandResponder:
         *,
         spi_flash: VirtualSpiFlash | None = None,
         profile: ControllerProfile | None = None,
-        session_state: SubcommandSessionState | None = None,
         device_info_bluetooth_address: bytes = DEFAULT_DEVICE_INFO_BLUETOOTH_ADDRESS,
     ) -> None:
         """Create a responder."""
         self._profile = profile or default_controller_profile()
-        self._session_state = (
-            session_state if session_state is not None else SubcommandSessionState()
-        )
         self._device_info_bluetooth_address = bytes(device_info_bluetooth_address)
         self._spi_flash = spi_flash or VirtualSpiFlash(profile=self._profile)
 
-    @property
-    def session_state(self) -> SubcommandSessionState:
-        """Return the mutable subcommand state owned by this responder."""
-        return self._session_state
-
     def set_device_info_bluetooth_address(self, bluetooth_address: bytes) -> None:
         """Update the Bluetooth address returned by subcommand 0x02."""
         if len(bluetooth_address) != 6:
@@ -74,13 +52,20 @@ class SubcommandResponder:
             raise ProtocolError(msg)
         self._device_info_bluetooth_address = bytes(bluetooth_address)
 
-    def respond(self, output_report: OutputReport, *, state: InputState, timer: int = 0) -> bytes:
+    def respond(
+        self,
+        output_report: OutputReport,
+        *,
+        state: InputState,
+        session: SwitchHidSession | None = None,
+        timer: int = 0,
+    ) -> bytes:
         """Return a 0x21 reply for an output report with a subcommand."""
         if output_report.subcommand_id is None:
             msg = "output report does not include a subcommand"
             raise ProtocolError(msg)
 
-        ack, data = self._reply_data(output_report)
+        ack, data = self._reply_data(output_report, session=session)
         return self._build_0x21_reply(
             subcommand_id=output_report.subcommand_id,
             ack=ack,
@@ -89,17 +74,31 @@ class SubcommandResponder:
             timer=timer,
         )
 
-    def _reply_data(self, output_report: OutputReport) -> tuple[int, bytes]:
+    def _reply_data(
+        self,
+        output_report: OutputReport,
+        *,
+        session: SwitchHidSession | None,
+    ) -> tuple[int, bytes]:
         subcommand_id = output_report.subcommand_id
         if subcommand_id is None:
             msg = "output report does not include a subcommand"
             raise ProtocolError(msg)
         if subcommand_id == 0x03:
-            return 0x80, self._set_input_report_mode(output_report.subcommand_payload)
+            return 0x80, self._set_input_report_mode(
+                output_report.subcommand_payload,
+                _require_session(session),
+            )
         if subcommand_id == 0x40:
-            return 0x80, self._set_imu_enabled(output_report.subcommand_payload)
+            return 0x80, self._set_imu_enabled(
+                output_report.subcommand_payload,
+                _require_session(session),
+            )
         if subcommand_id == 0x48:
-            return 0x80, self._set_vibration_enabled(output_report.subcommand_payload)
+            return 0x80, self._set_vibration_enabled(
+                output_report.subcommand_payload,
+                _require_session(session),
+            )
         if subcommand_id in SIMPLE_ACK_SUBCOMMANDS:
             return 0x80, b""
         if subcommand_id == 0x02:
@@ -114,23 +113,21 @@ class SubcommandResponder:
             return 0x80, _nfc_ir_mcu_state_payload(output_report.subcommand_payload)
         raise UnsupportedSubcommandError(subcommand_id, output_report.subcommand_payload)
 
-    def _set_input_report_mode(self, payload: bytes) -> bytes:
+    def _set_input_report_mode(self, payload: bytes, session: SwitchHidSession) -> bytes:
         mode = _first_payload_byte(payload, "set input report mode")
-        self._session_state.report_mode = mode
-        self._session_state.report_mode_supported = mode == SUPPORTED_INPUT_REPORT_MODE
-        self._session_state.unsupported_report_mode = (
-            None if self._session_state.report_mode_supported else mode
+        session.set_report_mode(
+            mode,
+            supported=mode == SUPPORTED_INPUT_REPORT_MODE,
         )
         return b""
 
-    def _set_imu_enabled(self, payload: bytes) -> bytes:
+    def _set_imu_enabled(self, payload: bytes, session: SwitchHidSession) -> bytes:
         imu_mode = _imu_enable_payload(payload, self._profile.imu_enable_modes)
-        self._session_state.imu_mode = imu_mode
-        self._session_state.imu_enabled = imu_mode != 0x00
+        session.set_imu_mode(imu_mode)
         return b""
 
-    def _set_vibration_enabled(self, payload: bytes) -> bytes:
-        self._session_state.vibration_enabled = _enable_payload(payload, "enable vibration")
+    def _set_vibration_enabled(self, payload: bytes, session: SwitchHidSession) -> bytes:
+        session.set_vibration_enabled(_enable_payload(payload, "enable vibration"))
         return b""
 
     def _spi_read_reply_data(self, payload: bytes) -> bytes:
@@ -171,6 +168,13 @@ def _first_payload_byte(payload: bytes, subcommand_name: str) -> int:
     return payload[0]
 
 
+def _require_session(session: SwitchHidSession | None) -> SwitchHidSession:
+    if session is None:
+        msg = "session-state subcommand requires an explicit SwitchHidSession"
+        raise ProtocolError(msg)
+    return session
+
+
 def _enable_payload(payload: bytes, subcommand_name: str) -> bool:
     value = _first_payload_byte(payload, subcommand_name)
     if value not in (0x00, 0x01):
@@ -183,7 +187,8 @@ def _imu_enable_payload(payload: bytes, accepted_modes: tuple[int, ...]) -> int:
     value = _first_payload_byte(payload, "enable IMU")
     if value in accepted_modes:
         return value
-    msg = "enable IMU subcommand argument must be 0x00 or 0x01"
+    accepted = ", ".join(f"0x{mode:02X}" for mode in accepted_modes)
+    msg = f"enable IMU subcommand argument must be one of: {accepted}"
     raise ProtocolError(msg)
 
 

swbt/report_loop.py

@@ -2,10 +2,13 @@
 
 import asyncio
 from collections import deque
+from collections.abc import Callable
 from contextlib import suppress
+from time import monotonic_ns
 
 from swbt.diagnostics import DiagnosticsRecorder
 from swbt.protocol.input_report import InputReportBuilder
+from swbt.protocol.session import SwitchHidSession
 from swbt.state_store import InputStateStore
 from swbt.transport.base import HidDeviceTransport
 
@@ -21,14 +24,18 @@ class ReportLoop:
         transport: HidDeviceTransport,
         state_store: InputStateStore,
         input_report_builder: InputReportBuilder,
+        session: SwitchHidSession,
         report_period_us: int = 8000,
         diagnostics: DiagnosticsRecorder | None = None,
+        clock_ns: Callable[[], int] = monotonic_ns,
     ) -> None:
         """Create a report loop helper."""
         self._transport = transport
         self._state_store = state_store
         self._report_period_seconds = report_period_us / 1_000_000
         self._input_report_builder = input_report_builder
+        self._session = session
+        self._clock_ns = clock_ns
         self._diagnostics = diagnostics
         self._reply_queue: deque[bytes] = deque()
         self._timer = 0
@@ -57,11 +64,13 @@ class ReportLoop:
         async with self._send_lock:
             await self._send_current_input_locked(reason=reason)
 
-    async def send_subcommand_reply(self, report: bytes) -> None:
-        """Send one 0x21 subcommand reply with the shared report timer."""
+    async def send_subcommand_reply(self, build_report: Callable[[], bytes]) -> bytes:
+        """Apply a subcommand transition and send its reply under the send lock."""
         async with self._send_lock:
+            report = build_report()
             await self._send_subcommand_reply_locked(report)
             self._holdoff_periodic_after_reply()
+            return report
 
     def queue_reply(self, report: bytes) -> None:
         """Queue one subcommand reply for priority transmission."""
@@ -80,7 +89,12 @@ class ReportLoop:
 
     async def _send_current_input_locked(self, *, reason: str) -> None:
         state = await self._state_store.snapshot()
-        report = self._input_report_builder.build_0x30(state, timer=self._timer)
+        imu_block = self._session.encode_imu(state.imu_frames, now_ns=self._clock_ns())
+        report = self._input_report_builder.build_0x30(
+            state,
+            timer=self._timer,
+            imu_block=imu_block,
+        )
         await self._send_report(report, reason=reason)
         self._advance_timer()
 

{swbt_python-0.2.0.dist-info → swbt_python-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swbt-python
-Version: 0.2.0
+Version: 0.3.0
 Summary: Python library for presenting an NX-compatible virtual Bluetooth HID input device.
 Keywords: bluetooth,bluetooth-hid,controller,gamepad,hid,nx
 Author: niart120
@@ -83,7 +83,6 @@ asyncio.run(main())
 ```
 
 Pro Controller 相当の仮想デバイスを作成し、ペアリング後に A ボタン入力を送信するコードの例です。
-接続情報ファイルの形式、入力 API の使い分けなどに関する詳しい説明は [Usage Guide](https://niart120.github.io/swbt-python/usage/) にあります。
 
 ### Joy-Con L/R
 
@@ -129,7 +128,7 @@ macOS 15.7.7 / CSR8510 A10 では、Pro Controller のペアリング、保存
 
 ### 実験的構成
 
-Linux は experimental です。手順は Hardware Guide に整備されていますが、専用 USB Bluetooth ドングルにアクセスできるか、ペアリングできるか、入力が反映されるかは未確認です。macOS は Pro Controller の限定観測だけで、Joy-Con、別ドングル、別ファームウェアでの互換性は未確認です。
+Linux は experimental です。手順は Hardware Guide に整備されていますが、専用 USB Bluetooth ドングルにアクセスできるか、ペアリングできるか、入力が反映されるかは未確認です。macOS は Pro Controller の一部挙動のみ検証済みです。Joy-Con、別ドングル、別ファームウェアでの互換性は未確認です。
 
 ## 開発
 

{swbt_python-0.2.0.dist-info → swbt_python-0.3.0.dist-info}/RECORD

@@ -10,25 +10,28 @@ swbt/gamepad/connection.py,sha256=My3deMw4L64UoEXjeyRNBs1D6UvrvkeC2P7yf_PLPYQ,77
 swbt/gamepad/constants.py,sha256=gDesRFvVxZ3SMSiP4qzd42em_Dt9M5hIu3-2exgKEus,84
 swbt/gamepad/core.py,sha256=vGY24NsCxJ37XY3jagk6P1DZzDM1JJwXdggZM7fk1Ug,15042
 swbt/gamepad/interface.py,sha256=GgPo5VwFhvcPIDy265R_dOQSYrBN1MYekqyPvIuXWQY,9431
-swbt/gamepad/output.py,sha256=CN0gp6rgaYkg8eTMVH-YpdHk2eZMkKUSsT_vmKaaPk8,3802
-swbt/gamepad/runtime.py,sha256=pkSQv2I6zAV7o2Iwu9pmJ7Rf06T2NJ4XU-dc4b1pAR8,29619
+swbt/gamepad/output.py,sha256=Et2efB09tkNZF50_0ANk-JjHTJsJBpbzSdsJeWMDtfA,4101
+swbt/gamepad/runtime.py,sha256=28wDzmCWWEihSLnzg2E0MYP73z3fIGoc2Vu98XZuH88,30508
 swbt/gamepad/transport_factory.py,sha256=2LLGIF3Bc4ufBNjp1AcdqNkHNP8ZBDFU2PNt898vo8o,2059
-swbt/input.py,sha256=M6TRm8iGteI2UaO4uHwNVC40m4p_S3IrnWm5f9pl_jA,18153
+swbt/imu.py,sha256=sT1_MsYECQlQ-pSfayD8gojD9l3w9zEtOI3xP1IovQM,4237
+swbt/input.py,sha256=7gv75lzrcmoV8Sijz7f1pvsheRrmUi_TCIMW3DjUVjw,22275
 swbt/probe.py,sha256=DnHMGhfDU2ooyC01JID7JQRly6BAyjFJVTEi-Mco0uY,7283
 swbt/protocol/__init__.py,sha256=Uvdlp06CBsKDivW1juPY-T5LaqJVCF00MbQaHl13XPo,35
 swbt/protocol/buttons.py,sha256=P0ojZ8tlpwwR007N_QL158a1rWOXYnYhZ3n8eCtZodc,1740
 swbt/protocol/descriptors.py,sha256=8J-l9xYUoCs5PODO6nkuEo4YCzhnTUzA_EAzKz-UC7g,2982
-swbt/protocol/input_report.py,sha256=9QQNU9NVISNiyVsXQjSMT9QwgXP4E-lB57t_H2k9J_k,2048
+swbt/protocol/imu_report.py,sha256=xpo21hiRD5Bnq8-z3PBLXoDxSZNAWf-hMOltguosEeg,5656
+swbt/protocol/input_report.py,sha256=jy8AuIwUFPbsyp2XVqBnpU_AD9MeFuMO8FWdrW4Bgig,2063
 swbt/protocol/output_report.py,sha256=00d-QZRBWFJ9k5ZLl5I0nSAe2pZY0oR50Z0YvZ2_YWs,1751
 swbt/protocol/profiles/__init__.py,sha256=LZH7FTwdMTyWlT-tJ2y558mdsPOHq9gOK5jYdgNkPUc,82
-swbt/protocol/profiles/base.py,sha256=l_9lbaMdRnYtGQPlgK-YpTFVFavfTKilGVh70YiWN80,9583
-swbt/protocol/profiles/joycon.py,sha256=dwK9OcguIsw42AmPkBi_9RzTLCgLRf40_P1eccUgzr8,2708
-swbt/protocol/profiles/pro_controller.py,sha256=9IN6xJtrDnt0w4VjOu339RH6tG_MSJ2m4O_b1aDC2bM,939
+swbt/protocol/profiles/base.py,sha256=hCYEZQ37TlJdwBzjVr-VBhG7kdyJF2V2VrLaBYEEbZM,9885
+swbt/protocol/profiles/joycon.py,sha256=vLuvdq217jkQZEkqs7yPuJ-8yUwK6x_6W_1f_tuvF9I,2715
+swbt/protocol/profiles/pro_controller.py,sha256=zR4rjaf1AfU1VFi2xkgGM4dqiJWAuX_jQ_1G9WrDfz8,957
 swbt/protocol/rumble.py,sha256=94Qq4gstmU5KlER-i0eW3mSr1HKY3CgArdz9D5gpqso,584
-swbt/protocol/spi.py,sha256=SiSN17WYKecEQS4q7DoBrKsfbK5QzeuoEhWGjJl66as,1938
-swbt/protocol/subcommand.py,sha256=CfhUO6cWadYq5i-I3EGbBXGOyEqbVmGy1KXxQml3EoQ,7756
+swbt/protocol/session.py,sha256=TtnnFySalCXsEUwVv0DX9w1E2xq1yFIfmgCrA6wGHzs,3758
+swbt/protocol/spi.py,sha256=buKyNYYOHOSYbpVh3Wa2968FL4VIO_43QcSXNowNfJs,2594
+swbt/protocol/subcommand.py,sha256=1Z3Xf8xo7AydhyTa3bHgHM24hN2YS37yp7eioOHTu0A,7633
 swbt/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-swbt/report_loop.py,sha256=sMb3fEHOAuxM7yD1V0aKocCJ36My1j5MjwQpVHKYM5k,4384
+swbt/report_loop.py,sha256=3qGLLWpJo_lWMdYXkkLqajZrQJtTLF2w7Z1z7iruB8c,4903
 swbt/state_store.py,sha256=Mf8uKR5CoQdzyMmqflNE_2KUWE_ZgmLaHcGXUcVThW4,2693
 swbt/transport/__init__.py,sha256=b_Vqsg0k_g7XclN9XHQrcJxqCwGIklxG5NqzISal4_I,68
 swbt/transport/_bumble_acl.py,sha256=RnueTwEgAd0w3YgxnXkw0AKQXMeECIRope96W-xQ1K8,1425
@@ -40,8 +43,8 @@ swbt/transport/_bumble_usb_devices.py,sha256=soAKiHTzeeTYdb7M357yaac-RxG2c_BiKWH
 swbt/transport/base.py,sha256=lAGAJjGMg5CwtdAKmefCZglWqT3mWzm7CFOOCGGKul4,5619
 swbt/transport/bumble.py,sha256=gB0vy1GW-1Mbg_EZuYSrdOKVClKyNEKXMy1jju41Bts,30147
 swbt/transport/fake.py,sha256=Pmr-9a3qg2v9Rs86wBjINdWmWi5KOZlcFMH3AOmWF58,12903
-swbt_python-0.2.0.dist-info/licenses/LICENSE,sha256=FzzUoYjuIh5DzpeaujIbDUTylYnyzcHRVU-_ZMyowyk,1065
-swbt_python-0.2.0.dist-info/WHEEL,sha256=uOqnPWqgFlbov4NeTCercq7cBQ2UN7xh5fiW55lOnAg,81
-swbt_python-0.2.0.dist-info/entry_points.txt,sha256=YYQc7VgoSy74iZ6s8Qr6iJpnvFoDpp8G4-v0KJH5TGo,48
-swbt_python-0.2.0.dist-info/METADATA,sha256=5R1B6tdPgNOolLPy3PBJkO60VFNfmFRKCtjD0_nbK9A,6158
-swbt_python-0.2.0.dist-info/RECORD,,
+swbt_python-0.3.0.dist-info/licenses/LICENSE,sha256=FzzUoYjuIh5DzpeaujIbDUTylYnyzcHRVU-_ZMyowyk,1065
+swbt_python-0.3.0.dist-info/WHEEL,sha256=uOqnPWqgFlbov4NeTCercq7cBQ2UN7xh5fiW55lOnAg,81
+swbt_python-0.3.0.dist-info/entry_points.txt,sha256=YYQc7VgoSy74iZ6s8Qr6iJpnvFoDpp8G4-v0KJH5TGo,48
+swbt_python-0.3.0.dist-info/METADATA,sha256=Dta7JIdGnIRn3tZ8xqguwesI8Vf94-4CIL5b-UMbHWA,5994
+swbt_python-0.3.0.dist-info/RECORD,,