rf-protocols 2.2.0__tar.gz → 3.1.0__tar.gz

{rf_protocols-2.2.0 → rf_protocols-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rf-protocols
-Version: 2.2.0
+Version: 3.1.0
 Summary: Library to decode and encode radio frequency signals.
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/home-assistant-libs/rf-protocols

{rf_protocols-2.2.0 → rf_protocols-3.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name         = "rf-protocols"
-version      = "2.2.0"
+version      = "3.1.0"
 license      = "MIT"
 description  = "Library to decode and encode radio frequency signals."
 readme       = "README.md"

rf_protocols-3.1.0/rf_protocols/__init__.py

@@ -0,0 +1,5 @@
+"""Library to decode and encode radio frequency signals."""
+
+from .commands import ModulationType, RadioFrequencyCommand
+
+__all__ = ["ModulationType", "RadioFrequencyCommand"]

rf_protocols-3.1.0/rf_protocols/codes/honeywell/string_lights/__init__.py

@@ -0,0 +1,5 @@
+"""Honeywell String Lights RF codes."""
+
+from rf_protocols.loader import get_codes
+
+CODES = get_codes("honeywell/string_lights")

rf_protocols-3.1.0/rf_protocols/codes/novy/cooker_hood/__init__.py

@@ -0,0 +1,8 @@
+"""Novy cooker-hood RF codes."""
+
+from rf_protocols.loader import CodeCollection, get_codes
+
+
+def get_codes_for_code(code: int) -> CodeCollection:
+    """Return the bundled `rf-protocols` collection for a Novy cooker-hood code."""
+    return get_codes(f"novy/cooker_hood/code_{code}")

rf_protocols-3.1.0/rf_protocols/codes/somfy/rts/__init__.py

@@ -0,0 +1,32 @@
+"""Somfy RTS button codes."""
+
+from enum import IntEnum
+
+from ....commands.somfy_rts import SomfyRTSCommand
+
+
+class SomfyRTSButton(IntEnum):
+    """Somfy RTS button identifiers.
+
+    Values are the protocol command nibbles transmitted in the frame.
+    """
+
+    MY = 0x1
+    UP = 0x2
+    DOWN = 0x4
+    PROG = 0x8
+
+    def to_command(
+        self,
+        *,
+        address: int,
+        rolling_code: int,
+        frame_repeats: int = 3,
+    ) -> SomfyRTSCommand:
+        """Build a SomfyRTSCommand for this button."""
+        return SomfyRTSCommand(
+            address=address,
+            rolling_code=rolling_code,
+            button=self.value,
+            frame_repeats=frame_repeats,
+        )

rf_protocols-2.2.0/rf_protocols/commands.py → rf_protocols-3.1.0/rf_protocols/commands/__init__.py

@@ -1,10 +1,9 @@
-"""Common RF command definitions."""
+"""RF command encoders. Import directly from each protocol submodule."""
 
 from __future__ import annotations
 
 import abc
 from enum import StrEnum
-from typing import override
 
 
 class ModulationType(StrEnum):
@@ -55,33 +54,3 @@ class RadioFrequencyCommand(abc.ABC):
             f"{self.frequency / 1_000_000:g} MHz, "
             f"repeat={self.repeat_count})"
         )
-
-
-class OOKCommand(RadioFrequencyCommand):
-    """OOK command with raw timings."""
-
-    timings: list[int]
-
-    def __init__(
-        self,
-        *,
-        frequency: int,
-        timings: list[int],
-        repeat_count: int = 0,
-        symbol_rate: int | None = None,
-        output_power: float | None = None,
-    ) -> None:
-        """Initialize the OOK command."""
-        super().__init__(
-            frequency=frequency,
-            modulation=ModulationType.OOK,
-            repeat_count=repeat_count,
-            symbol_rate=symbol_rate,
-            output_power=output_power,
-        )
-        self.timings = timings
-
-    @override
-    def get_raw_timings(self) -> list[int]:
-        """Get raw timings."""
-        return self.timings

rf_protocols-3.1.0/rf_protocols/commands/kaku.py

@@ -0,0 +1,153 @@
+"""Protocol for KAKU compatible devices.
+
+Pulse Position Modulation with 32 or 36 symbols, used by self-learning
+Intertechno-type sockets and compatible devices (for example some Hama models).
+
+Symbols use a time base ``T``:
+
+			 ____      ____
+Bit 0    : _|    |____|    |____________________
+			|<1T>|<1T>|<1T>|<--------5T-------->|
+
+			 ____                      ____
+Bit 1    : _|    |____________________|    |____
+			|<1T>|<--------5T-------->|<1T>|<1T>|
+
+			 ____      ____
+Bit X    : _|    |____|    |____
+			|<1T>|<1T>|<1T>|<1T>|
+
+			 ____
+Sync     : _|    |_________ _ _ _ ________
+			|<1T>|<----------11T--------->|
+
+			 ____
+Pause    : _|    |___________ _ _ _ ____________
+			|<1T>|<-----------39T-------------->|
+
+Telegram layout:
+- Sync
+- 32 or 36 symbols
+- Pause
+
+Each transmission is typically repeated four times.
+
+Common bit assignment for KAKU-style devices:
+- 26 bits system code
+- 1 bit group (0=single, 1=group)
+- 1 bit on/off
+- 4 bits channel
+
+Dimming commands:
+- 26 bits system code
+- 1 bit group (0=single, 1=group)
+- 1 bit X
+- 4 bits channel
+- 4 bits dim level (0-15)
+
+Manufacturer-specific notes from the reference:
+- Intertechno (self-learning): step duration around 275 us
+- Hama 00121938: similar format, step duration around 250 us, inverted channel bits
+
+Reference chapter:
+https://www.seegel-systeme.de/2015/09/05/funksteckdosen-mit-dem-raspberry-pi-steuern/
+"""
+
+from __future__ import annotations
+
+from typing import override
+
+from . import ModulationType, RadioFrequencyCommand
+
+_DEFAULT_FREQUENCY = 433_920_000
+_DEFAULT_REPEATS = 4
+_DEFAULT_TIMEBASE_US = 275
+
+
+class KakuCommand(RadioFrequencyCommand):
+	"""Encode a KAKU-compatible PPM frame.
+
+	Data layout is either:
+	- 32 symbols: 26-bit id, group bit, on/off bit, 4-bit channel
+	- 36 symbols: 26-bit id, group bit, X symbol, 4-bit channel, 4-bit dim level
+	"""
+
+	id: int
+	group: bool
+	channel: int
+	on: bool | None
+	dimlevel: int | None
+	timebase_us: int
+
+	def __init__(
+		self,
+		*,
+		id: int,
+		group: bool,
+		channel: int | None = None,
+		on: bool | None = None,
+		dimlevel: int | None = None,
+		frame_repeats: int = _DEFAULT_REPEATS,
+		frequency: int = _DEFAULT_FREQUENCY,
+		timebase_us: int = _DEFAULT_TIMEBASE_US,
+	) -> None:
+		"""Initialize the KAKU command."""
+
+		if id < 0 or id >= (1 << 26):
+			raise ValueError("id must be in range 0..67108863 (26-bit)")
+		if channel is None:
+			if not group:
+				raise ValueError("channel is required when group is False")
+			channel = 1
+		if channel < 1 or channel > 16:
+			raise ValueError("channel must be in range 1..16")
+		if (on is None) == (dimlevel is None):
+			raise ValueError("provide exactly one of 'on' or 'dimlevel'")
+		if dimlevel is not None and (dimlevel < 0 or dimlevel > 100):
+			raise ValueError("dimlevel must be in range 0..100")
+
+		super().__init__(
+			frequency=frequency,
+			modulation=ModulationType.OOK,
+			repeat_count=frame_repeats,
+		)
+		self.id = id
+		self.group = group
+		self.channel = channel
+		self.on = on
+		self.dimlevel = dimlevel
+		self.timebase_us = timebase_us
+
+	@override
+	def get_raw_timings(self) -> list[int]:
+		"""Compute KAKU PPM frame timings."""
+		_symbols = {
+			"0": [self.timebase_us, -self.timebase_us, self.timebase_us, -5 * self.timebase_us],
+			"1": [self.timebase_us, -5 * self.timebase_us, self.timebase_us, -self.timebase_us],
+			"X": [self.timebase_us, -self.timebase_us, self.timebase_us, -self.timebase_us],
+			"sync": [self.timebase_us, -11 * self.timebase_us],
+			"pause": [self.timebase_us, -39 * self.timebase_us],
+		}
+
+		# add ID and group bit
+		symstr: list[str] = [*format(self.id, "026b"), "1" if self.group else "0"]
+
+		if self.dimlevel is None:
+			# add on/off bit
+			symstr.append("1" if self.on else "0")
+		else:
+			# add X symbol
+			symstr.append("X")
+
+		symstr.extend(format(self.channel - 1, "04b"))
+		if self.dimlevel is not None:
+			dim_steps = round(self.dimlevel * 15 / 100)
+			symstr.extend(format(dim_steps, "04b"))
+
+		timings: list[int] = []
+		timings.extend(_symbols["sync"])
+		for s in symstr:
+			timings.extend(_symbols[s])
+		timings.extend(_symbols["pause"])
+
+		return timings

rf_protocols-3.1.0/rf_protocols/commands/ook.py

@@ -0,0 +1,37 @@
+"""OOK (On-Off Keying) RF command with raw timings."""
+
+from __future__ import annotations
+
+from typing import override
+
+from . import ModulationType, RadioFrequencyCommand
+
+
+class OOKCommand(RadioFrequencyCommand):
+    """OOK command with raw timings."""
+
+    timings: list[int]
+
+    def __init__(
+        self,
+        *,
+        frequency: int,
+        timings: list[int],
+        repeat_count: int = 0,
+        symbol_rate: int | None = None,
+        output_power: float | None = None,
+    ) -> None:
+        """Initialize the OOK command."""
+        super().__init__(
+            frequency=frequency,
+            modulation=ModulationType.OOK,
+            repeat_count=repeat_count,
+            symbol_rate=symbol_rate,
+            output_power=output_power,
+        )
+        self.timings = timings
+
+    @override
+    def get_raw_timings(self) -> list[int]:
+        """Get raw timings."""
+        return self.timings

rf_protocols-3.1.0/rf_protocols/commands/pt2262.py

@@ -0,0 +1,102 @@
+"""Encoder for PT2262 / HX2262 and compatible tristate RF chips.
+
+Chip datasheet: https://cdn-shop.adafruit.com/datasheets/PT2262.pdf
+
+Devices which use PT2262 or compatible chips include:
+
+- BAT RC 3500-A
+- Brennenstuhl RCS 1000 N Comfort
+- Emil Lux GmbH RCS-14G
+- ELRO AB440D, AB440IS, AB440L, AB440S, AB440WD
+- Intertechno CMR-1000, CMR-1224, CMR-300, CMR-500, ...
+- Intertechno IT-1500, IT-1500R, IT-2000, IT-2000R, ...
+- me FLS 100
+- mumbi FS300
+- REV Ritter 8342C
+- Vivanco FSS 31000W
+- RSL366
+- Goobay 94503
+
+A frame consists of 12 symbols (0/1/F) followed by a sync symbol. The chip has
+12 inputs A0..A11 which can be tied to VCC, GND, or left floating. GND sends
+symbol 0, VCC sends symbol 1, and floating sends symbol F. The symbols are
+encoded against a time base ``a`` determined by the crystal connected to the
+chip::
+
+              ____              ____
+    Bit 0 : _|    |____________|    |____________
+             |<4a>|<---12a---->|<4a>|<---12a---->|
+
+              ____________      ____________
+    Bit 1 : _|            |____|            |____
+             |<---12a---->|<4a>|<---12a---->|<4a>|
+
+              ____              ____________
+    Bit F : _|    |____________|            |____
+             |<4a>|<---12a---->|<---12a---->|<4a>|
+
+              ____
+    Sync  : _|    |___________ _ _ _ ____________
+             |<4a>|<-----------124a------------->|
+
+References:
+
+- https://www.seegel-systeme.de/2017/03/28/uebersicht-funksteckdosen/
+- https://www.seegel-systeme.de/2015/09/05/funksteckdosen-mit-dem-raspberry-pi-steuern/
+"""
+
+from __future__ import annotations
+
+from typing import override
+
+from . import ModulationType, RadioFrequencyCommand
+
+_VALID_SYMBOLS = frozenset("01F")
+
+
+class PT2262Command(RadioFrequencyCommand):
+    """OOK command for PT2262 / HX2262 and compatible tristate chips."""
+
+    data: str
+    timebase_us: int
+
+    def __init__(
+        self,
+        *,
+        data: str,
+        timebase_us: int = 350,
+        frequency: int = 433_920_000,
+        repeat_count: int = 5,
+    ) -> None:
+        """Initialize the PT2262 command from a 12-symbol tristate string."""
+        normalized_data = data.upper()
+        if len(normalized_data) != 12:
+            raise ValueError("data must be exactly 12 characters long")
+        if not set(normalized_data).issubset(_VALID_SYMBOLS):
+            raise ValueError("data must contain only symbols '0', '1', and 'F'")
+
+        super().__init__(
+            frequency=frequency,
+            modulation=ModulationType.OOK,
+            repeat_count=repeat_count,
+        )
+        self.data = normalized_data
+        self.timebase_us = timebase_us
+
+    @override
+    def get_raw_timings(self) -> list[int]:
+        """Compute the PT2262 frame timings followed by the sync symbol."""
+        short_us = 4 * self.timebase_us
+        long_us = 12 * self.timebase_us
+        sync_low_us = 124 * self.timebase_us
+        symbols = {
+            "0": [short_us, -long_us, short_us, -long_us],
+            "1": [long_us, -short_us, long_us, -short_us],
+            "F": [short_us, -long_us, long_us, -short_us],
+        }
+
+        timings: list[int] = []
+        for symbol in self.data:
+            timings.extend(symbols[symbol])
+        timings.extend([short_us, -sync_low_us])
+        return timings

rf_protocols-3.1.0/rf_protocols/commands/somfy_rts.py

@@ -0,0 +1,116 @@
+"""Somfy RTS RF command definitions."""
+
+from __future__ import annotations
+
+from typing import override
+
+from . import ModulationType, RadioFrequencyCommand
+
+# Somfy RTS operates at 433.42 MHz with OOK modulation.
+_SOMFY_RTS_FREQUENCY = 433_420_000
+_SOMFY_RTS_REPEAT_COUNT = 2
+
+
+class SomfyRTSCommand(RadioFrequencyCommand):
+    """Somfy RTS rolling code command.
+
+    Encodes a complete Somfy RTS transmission, including wake-up pulse, the
+    initial 2-sync frame, and ``frame_repeats`` additional 7-sync frames.
+
+    All frame parameters are supplied at construction time. The rolling code
+    counter must be tracked and incremented by the caller between
+    transmissions.
+
+    Protocol reference: https://pushstack.wordpress.com/somfy-rts-protocol/
+    """
+
+    address: int
+    rolling_code: int
+    button: int
+    frame_repeats: int
+
+    def __init__(
+        self,
+        *,
+        address: int,
+        rolling_code: int,
+        button: int,
+        frame_repeats: int = 3,
+    ) -> None:
+        """Initialize the Somfy RTS command."""
+        super().__init__(
+            frequency=_SOMFY_RTS_FREQUENCY,
+            modulation=ModulationType.OOK,
+            repeat_count=_SOMFY_RTS_REPEAT_COUNT,
+        )
+        self.address = address
+        self.rolling_code = rolling_code
+        self.button = button
+        self.frame_repeats = frame_repeats
+
+    @override
+    def get_raw_timings(self) -> list[int]:
+        """Compute Somfy RTS frame timings.
+
+        Builds the 7-byte frame, applies checksum and obfuscation, then
+        encodes the result as Manchester-coded OOK pulses. Consecutive
+        same-polarity values produced by Manchester transitions are merged so
+        the output strictly alternates between positive (mark) and negative
+        (space) microseconds.
+        """
+        # ── Build 7-byte frame ────────────────────────────────────────────
+        frame = bytearray(7)
+        frame[0] = 0xA7  # encryption key (fixed)
+        frame[1] = self.button << 4  # command nibble; lower = checksum
+        frame[2] = (self.rolling_code >> 8) & 0xFF
+        frame[3] = self.rolling_code & 0xFF
+        frame[4] = (self.address >> 16) & 0xFF
+        frame[5] = (self.address >> 8) & 0xFF
+        frame[6] = self.address & 0xFF
+
+        # Checksum: XOR of all nibbles across all 7 bytes
+        cksum = 0
+        for byte in frame:
+            cksum ^= byte ^ (byte >> 4)
+        frame[1] |= cksum & 0x0F
+
+        # Obfuscation: rolling XOR
+        for i in range(1, 7):
+            frame[i] ^= frame[i - 1]
+
+        # ── Build OOK pulse sequence ──────────────────────────────────────
+        # Positive = mark (HIGH), negative = space (LOW), units = µs.
+        # Consecutive same-polarity values are merged to maintain alternation.
+        timings: list[int] = []
+
+        def add(us: int) -> None:
+            if timings and (us > 0) == (timings[-1] > 0):
+                timings[-1] += us
+            else:
+                timings.append(us)
+
+        def encode_frame(sync: int) -> None:
+            if sync == 2:
+                add(9415)
+                add(-89565)  # wake-up pulse + silence
+            for _ in range(sync):
+                add(2416)
+                add(-2416)  # hardware sync pulses
+            add(4550)
+            add(-604)  # software sync
+            # 56 data bits, MSB first, Manchester encoded
+            # Bit 1 = rising edge (LOW→HIGH), Bit 0 = falling edge (HIGH→LOW)
+            for b in range(56):
+                if (frame[b // 8] >> (7 - b % 8)) & 1:
+                    add(-604)
+                    add(604)
+                else:
+                    add(604)
+                    add(-604)
+            add(-30415)  # inter-frame gap
+
+        encode_frame(2)
+        for _ in range(self.frame_repeats):
+            encode_frame(7)
+
+        return timings

{rf_protocols-2.2.0 → rf_protocols-3.1.0}/rf_protocols/parser.py

@@ -4,7 +4,8 @@ from __future__ import annotations
 
 from typing import Any
 
-from .commands import OOKCommand, RadioFrequencyCommand
+from .commands import RadioFrequencyCommand
+from .commands.ook import OOKCommand
 
 
 def parse_sub_content(content: str) -> RadioFrequencyCommand:

{rf_protocols-2.2.0 → rf_protocols-3.1.0}/rf_protocols.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rf-protocols
-Version: 2.2.0
+Version: 3.1.0
 Summary: Library to decode and encode radio frequency signals.
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/home-assistant-libs/rf-protocols

{rf_protocols-2.2.0 → rf_protocols-3.1.0}/rf_protocols.egg-info/SOURCES.txt

@@ -2,7 +2,6 @@ LICENSE
 README.md
 pyproject.toml
 rf_protocols/__init__.py
-rf_protocols/commands.py
 rf_protocols/loader.py
 rf_protocols/parser.py
 rf_protocols.egg-info/PKG-INFO
@@ -10,8 +9,10 @@ rf_protocols.egg-info/SOURCES.txt
 rf_protocols.egg-info/dependency_links.txt
 rf_protocols.egg-info/requires.txt
 rf_protocols.egg-info/top_level.txt
+rf_protocols/codes/honeywell/string_lights/__init__.py
 rf_protocols/codes/honeywell/string_lights/turn_off.sub
 rf_protocols/codes/honeywell/string_lights/turn_on.sub
+rf_protocols/codes/novy/cooker_hood/__init__.py
 rf_protocols/codes/novy/cooker_hood/code_1/ambient_light.sub
 rf_protocols/codes/novy/cooker_hood/code_1/light.sub
 rf_protocols/codes/novy/cooker_hood/code_1/minus.sub
@@ -62,6 +63,11 @@ rf_protocols/codes/novy/cooker_hood/code_9/light.sub
 rf_protocols/codes/novy/cooker_hood/code_9/minus.sub
 rf_protocols/codes/novy/cooker_hood/code_9/plus.sub
 rf_protocols/codes/novy/cooker_hood/code_9/power.sub
-tests/test_commands.py
+rf_protocols/codes/somfy/rts/__init__.py
+rf_protocols/commands/__init__.py
+rf_protocols/commands/kaku.py
+rf_protocols/commands/ook.py
+rf_protocols/commands/pt2262.py
+rf_protocols/commands/somfy_rts.py
 tests/test_loader.py
 tests/test_parser.py

{rf_protocols-2.2.0 → rf_protocols-3.1.0}/tests/test_loader.py

@@ -6,7 +6,9 @@ from pathlib import Path
 import pytest
 
 import rf_protocols
-from rf_protocols import CodeCollection, ModulationType, OOKCommand, get_codes
+from rf_protocols import ModulationType
+from rf_protocols.commands.ook import OOKCommand
+from rf_protocols.loader import CodeCollection, get_codes
 
 _BUNDLED_CODES_ROOT = Path(rf_protocols.__file__).parent / "codes"
 _BUNDLED_SUB_FILES = sorted(_BUNDLED_CODES_ROOT.rglob("*.sub"))

{rf_protocols-2.2.0 → rf_protocols-3.1.0}/tests/test_parser.py

@@ -2,7 +2,8 @@
 
 import pytest
 
-from rf_protocols import OOKCommand, parse_sub_content
+from rf_protocols.commands.ook import OOKCommand
+from rf_protocols.parser import parse_sub_content
 
 _SAMPLE_SUB = """\
 Filetype: Flipper SubGhz RAW File

rf_protocols-2.2.0/rf_protocols/__init__.py

@@ -1,14 +0,0 @@
-"""Library to decode and encode radio frequency signals."""
-
-from .commands import ModulationType, OOKCommand, RadioFrequencyCommand
-from .loader import CodeCollection, get_codes
-from .parser import parse_sub_content
-
-__all__ = [
-    "CodeCollection",
-    "ModulationType",
-    "OOKCommand",
-    "RadioFrequencyCommand",
-    "get_codes",
-    "parse_sub_content",
-]

rf_protocols-2.2.0/tests/test_commands.py

@@ -1,103 +0,0 @@
-"""Tests for the RF protocol definitions."""
-
-from rf_protocols import ModulationType, OOKCommand, RadioFrequencyCommand
-
-
-def test_modulation_type_ook() -> None:
-    """Test ModulationType enum has OOK value."""
-    assert ModulationType.OOK == "OOK"
-    assert ModulationType.OOK.value == "OOK"
-
-
-class _MockCommand(RadioFrequencyCommand):
-    """Simple concrete command for testing the base class."""
-
-    def __init__(
-        self,
-        *,
-        frequency: int = 433_920_000,
-        modulation: ModulationType = ModulationType.OOK,
-        repeat_count: int = 0,
-        symbol_rate: int | None = None,
-        output_power: float | None = None,
-    ) -> None:
-        super().__init__(
-            frequency=frequency,
-            modulation=modulation,
-            repeat_count=repeat_count,
-            symbol_rate=symbol_rate,
-            output_power=output_power,
-        )
-
-    def get_raw_timings(self) -> list[int]:
-        """Return a simple test pattern."""
-        return [350, -1050, 350, -350]
-
-
-def test_command_defaults() -> None:
-    """Test RadioFrequencyCommand default values."""
-    cmd = _MockCommand()
-    assert cmd.frequency == 433_920_000
-    assert cmd.repeat_count == 0
-    assert cmd.modulation == ModulationType.OOK
-    assert cmd.symbol_rate is None
-    assert cmd.output_power is None
-
-
-def test_command_custom_values() -> None:
-    """Test RadioFrequencyCommand with custom values."""
-    cmd = _MockCommand(
-        frequency=868_000_000,
-        repeat_count=3,
-        symbol_rate=4800,
-        output_power=10.0,
-    )
-    assert cmd.frequency == 868_000_000
-    assert cmd.repeat_count == 3
-    assert cmd.modulation == ModulationType.OOK
-    assert cmd.symbol_rate == 4800
-    assert cmd.output_power == 10.0
-
-
-def test_command_get_raw_timings() -> None:
-    """Test get_raw_timings returns expected timings."""
-    cmd = _MockCommand()
-    assert cmd.get_raw_timings() == [350, -1050, 350, -350]
-
-
-def test_ook_command() -> None:
-    """Test OOKCommand with raw timings."""
-    timings = [350, -1050, 350, -350]
-    cmd = OOKCommand(frequency=433_920_000, timings=timings)
-    assert cmd.frequency == 433_920_000
-    assert cmd.modulation == ModulationType.OOK
-    assert cmd.repeat_count == 0
-    assert cmd.get_raw_timings() == timings
-
-
-def test_command_repr() -> None:
-    """Test RadioFrequencyCommand has a readable repr for subclasses."""
-    cmd = OOKCommand(
-        frequency=433_920_000,
-        timings=[350, -1050],
-        repeat_count=5,
-    )
-    assert repr(cmd) == "OOKCommand(OOK, 433.92 MHz, repeat=5)"
-
-
-def test_ook_command_custom_values() -> None:
-    """Test OOKCommand with custom radio parameters."""
-    timings = [500, -1000]
-    cmd = OOKCommand(
-        frequency=868_000_000,
-        timings=timings,
-        repeat_count=2,
-        symbol_rate=4800,
-        output_power=10.0,
-    )
-    assert cmd.frequency == 868_000_000
-    assert cmd.modulation == ModulationType.OOK
-    assert cmd.repeat_count == 2
-    assert cmd.symbol_rate == 4800
-    assert cmd.output_power == 10.0
-    assert cmd.get_raw_timings() == timings