rtlamr-python 1.0.0__py3-none-any.whl

rtlamr_python/protocols/netidm.py

@@ -0,0 +1,119 @@
+"""NetIDM (Net Meter Interval Data Message) protocol parser.
+
+Port of rtlamr-go/netidm/netidm.go.
+
+Same preamble, packet size, and CRC checks as IDM.  Fields differ starting
+at byte 15: the NetIDM carries LastGeneration, LastConsumption,
+LastConsumptionNet, and 27 × 14-bit differential intervals (vs IDM's
+47 × 9-bit intervals).
+"""
+
+from __future__ import annotations
+
+import struct
+from dataclasses import dataclass
+
+import numpy as np
+
+from rtlamr_python import crc
+from rtlamr_python.protocols.idm import _PREAMBLE, _PACKET_SYMBOLS, _serial_crc_buf
+
+
+def make_config(chip_length: int = 72):
+    from rtlamr_python.decoder import Config
+    return Config(
+        chip_length=chip_length,
+        preamble_bits=_PREAMBLE.copy(),
+        packet_symbols=_PACKET_SYMBOLS,
+    )
+
+
+@dataclass
+class NetIDM:
+    preamble: int
+    protocol_id: int
+    packet_length: int
+    hamming_code: int
+    application_version: int
+    ert_type: int
+    ert_serial_number: int
+    consumption_interval_count: int
+    programming_state: int
+    last_generation: int    # 3 bytes, bytes[28:31]
+    last_consumption: int   # 3 bytes, bytes[25:28]
+    last_consumption_net: int  # 4 bytes, bytes[34:38]
+    differential_consumption_intervals: list   # 27 × 14-bit values
+    transmit_time_offset: int
+    serial_number_crc: int
+    packet_crc: int
+
+    def as_dict(self) -> dict:
+        return {
+            "type": "NetIDM",
+            "endpoint_id": self.ert_serial_number,
+            "ert_type": self.ert_type,
+            "consumption_interval_count": self.consumption_interval_count,
+            "last_consumption": self.last_consumption,
+            "last_generation": self.last_generation,
+            "last_consumption_net": self.last_consumption_net,
+            "differential_consumption_intervals": self.differential_consumption_intervals,
+        }
+
+
+def parse(raw: bytes | bytearray) -> NetIDM | None:
+    if len(raw) < 92:
+        return None
+    if crc.checksum(raw[4:92]) != crc.RESIDUE:
+        return None
+    if crc.checksum(_serial_crc_buf(raw)) != crc.RESIDUE:
+        return None
+
+    preamble = struct.unpack_from(">I", raw, 0)[0]
+    protocol_id = raw[4]
+    packet_length_b = raw[5]
+    hamming_code = raw[6]
+    application_version = raw[7]
+    ert_type = raw[8] & 0x0F
+    ert_serial_number = struct.unpack_from(">I", raw, 9)[0]
+
+    if ert_serial_number == 0:
+        return None
+
+    consumption_interval_count = raw[13]
+    programming_state = raw[14]
+
+    # 3-byte big-endian values not aligned to 4-byte boundaries.
+    last_consumption = (raw[25] << 16) | (raw[26] << 8) | raw[27]
+    last_generation = (raw[28] << 16) | (raw[29] << 8) | raw[30]
+    last_consumption_net = struct.unpack_from(">I", raw, 34)[0]
+
+    # 27 differential intervals packed at 14 bits each, starting at bit 304.
+    bits = "".join(f"{b:08b}" for b in raw[:92])
+    intervals = []
+    offset = 304
+    for _ in range(27):
+        intervals.append(int(bits[offset:offset + 14], 2))
+        offset += 14
+
+    transmit_time_offset = struct.unpack_from(">H", raw, 86)[0]
+    serial_number_crc = struct.unpack_from(">H", raw, 88)[0]
+    packet_crc = struct.unpack_from(">H", raw, 90)[0]
+
+    return NetIDM(
+        preamble=preamble,
+        protocol_id=protocol_id,
+        packet_length=packet_length_b,
+        hamming_code=hamming_code,
+        application_version=application_version,
+        ert_type=ert_type,
+        ert_serial_number=ert_serial_number,
+        consumption_interval_count=consumption_interval_count,
+        programming_state=programming_state,
+        last_generation=last_generation,
+        last_consumption=last_consumption,
+        last_consumption_net=last_consumption_net,
+        differential_consumption_intervals=intervals,
+        transmit_time_offset=transmit_time_offset,
+        serial_number_crc=serial_number_crc,
+        packet_crc=packet_crc,
+    )

rtlamr_python/protocols/r900.py

@@ -0,0 +1,63 @@
+"""R900 (Neptune R900) water meter protocol.
+
+Port of rtlamr-go/r900/r900.go.
+
+R900 uses a completely different signal chain from the Manchester protocols:
+  - 4-chip symbols (6 possible values) instead of 2-chip Manchester
+  - Reed-Solomon error correction over GF(32, 37, 2)
+  - Different center frequency: 912,380,000 Hz
+
+Signal decoding is handled by R900Decoder in src/r900_decoder.py.
+This module only contains the message dataclass and bit-field extraction.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+_R900_CENTER_FREQ = 912_380_000  # Hz — different from other ERT protocols
+
+
+@dataclass
+class R900:
+    meter_id: int       # 32 bits
+    unkn1: int          # 8 bits
+    no_use: int         # 6 bits — day bins with no usage
+    backflow: int       # 2 bits — backflow detected past 35 days (hi/lo)
+    consumption: int    # 24 bits
+    unkn3: int          # 2 bits
+    leak: int           # 4 bits — day bins with leak
+    leak_now: int       # 2 bits — leak past 24 hours (hi/lo)
+
+    def as_dict(self) -> dict:
+        return {
+            "type": "R900",
+            "endpoint_id": self.meter_id,
+            "consumption": self.consumption,
+            "no_use": self.no_use,
+            "backflow": self.backflow,
+            "leak": self.leak,
+            "leak_now": self.leak_now,
+        }
+
+
+def parse_bits(bits: str) -> R900 | None:
+    """Parse an R900 message from a 80-bit string of '0'/'1' characters.
+
+    Input is the payload bits after Reed-Solomon verification, derived from
+    21 base-6 symbols (each encoded as 5 bits).
+    """
+    if len(bits) < 80:
+        return None
+    meter_id = int(bits[0:32], 2)
+    if meter_id == 0:
+        return None
+    unkn1 = int(bits[32:40], 2)
+    no_use = int(bits[40:46], 2)
+    backflow = int(bits[46:48], 2)
+    consumption = int(bits[48:72], 2)
+    unkn3 = int(bits[72:74], 2)
+    leak = int(bits[74:78], 2)
+    leak_now = int(bits[78:80], 2)
+    return R900(meter_id, unkn1, no_use, backflow, consumption, unkn3, leak, leak_now)

rtlamr_python/protocols/scm.py

@@ -0,0 +1,74 @@
+"""SCM (Standard Consumption Message) protocol parser.
+
+Port of rtlamr-go/scm/scm.go.
+
+Packet: 12 bytes (96 bits total, including 21-bit preamble).
+CRC: BCH-16 (poly=0x6F63, init=0, xorout=0) over bytes[2:12].
+Fields are extracted from bit positions within the 96-bit packet because
+the 21-bit preamble is not byte-aligned.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from rtlamr_python import crc
+
+_PREAMBLE = np.array([int(b) for b in "111110010101001100000"], dtype=np.uint8)
+_PACKET_SYMBOLS = 96  # 12 bytes × 8 bits
+
+
+def make_config(chip_length: int = 72):
+    from rtlamr_python.decoder import Config
+    return Config(
+        chip_length=chip_length,
+        preamble_bits=_PREAMBLE.copy(),
+        packet_symbols=_PACKET_SYMBOLS,
+    )
+
+
+@dataclass
+class SCM:
+    endpoint_id: int    # 26-bit ERT ID
+    endpoint_type: int  # 4-bit meter type
+    tamper_phy: int     # 2-bit physical tamper indicator
+    tamper_enc: int     # 2-bit encoder tamper indicator
+    consumption: int    # 24-bit consumption value
+    packet_crc: int     # 16-bit checksum
+
+    def as_dict(self) -> dict:
+        return {
+            "type": "SCM",
+            "endpoint_id": self.endpoint_id,
+            "endpoint_type": self.endpoint_type,
+            "tamper_phy": self.tamper_phy,
+            "tamper_enc": self.tamper_enc,
+            "consumption": self.consumption,
+        }
+
+
+def parse(raw: bytes | bytearray) -> SCM | None:
+    if len(raw) < 12:
+        return None
+    if not crc.bch_valid(raw):
+        return None
+    bits = "".join(f"{b:08b}" for b in raw[:12])
+    # Fields are at non-byte-aligned positions within the 96-bit packet.
+    # Bit layout from rtlamr-go/scm/scm.go NewSCM():
+    #   bits[21:23] + bits[56:80] → 26-bit ERT ID
+    #   bits[24:26]  → TamperPhy
+    #   bits[26:30]  → ERTType
+    #   bits[30:32]  → TamperEnc
+    #   bits[32:56]  → Consumption
+    #   bits[80:96]  → Checksum
+    endpoint_id = int(bits[21:23] + bits[56:80], 2)
+    if endpoint_id == 0:
+        return None
+    endpoint_type = int(bits[26:30], 2)
+    tamper_phy = int(bits[24:26], 2)
+    tamper_enc = int(bits[30:32], 2)
+    consumption = int(bits[32:56], 2)
+    packet_crc = int(bits[80:96], 2)
+    return SCM(endpoint_id, endpoint_type, tamper_phy, tamper_enc, consumption, packet_crc)

rtlamr_python/protocols/scmplus.py

@@ -0,0 +1,92 @@
+"""SCM+ (Standard Consumption Message Plus) packet parser.
+
+Port of rtlamr-go/scmplus/scmplus.go.
+
+Packet layout (16 bytes, big-endian):
+  offset  size  field
+  0       2     FrameSync   uint16
+  2       1     ProtocolID  uint8   must == 0x1E
+  3       1     EndpointType uint8
+  4       4     EndpointID  uint32  must be non-zero
+  8       4     Consumption uint32
+  12      2     Tamper      uint16
+  14      2     PacketCRC   uint16
+
+CRC covers bytes[2:14] (the 12 bytes before PacketCRC); valid when
+CCITT16(bytes[2:]) == 0x1D0F (the residue includes PacketCRC itself).
+"""
+
+import struct
+from dataclasses import dataclass
+
+import numpy as np
+
+from rtlamr_python import crc
+
+_STRUCT = struct.Struct(">HBBIIHH")
+_PROTOCOL_ID = 0x1E
+
+_PREAMBLE = np.array([int(b) for b in "0001011010100011"], dtype=np.uint8)
+_PACKET_SYMBOLS = 128  # 16 bytes × 8 bits
+
+
+def make_config(chip_length: int = 72):
+    from rtlamr_python.decoder import Config
+    return Config(
+        chip_length=chip_length,
+        preamble_bits=_PREAMBLE.copy(),
+        packet_symbols=_PACKET_SYMBOLS,
+    )
+
+
+@dataclass
+class SCMPlus:
+    frame_sync: int
+    protocol_id: int
+    endpoint_type: int
+    endpoint_id: int
+    consumption: int
+    tamper: int
+    packet_crc: int
+
+    def msg_type(self) -> str:
+        return "SCM+"
+
+    def as_dict(self) -> dict:
+        return {
+            "type": self.msg_type(),
+            "endpoint_id": self.endpoint_id,
+            "endpoint_type": self.endpoint_type,
+            "consumption": self.consumption,
+            "tamper": f"0x{self.tamper:04X}",
+            "packet_crc": f"0x{self.packet_crc:04X}",
+        }
+
+
+def parse(raw: bytes | bytearray) -> SCMPlus | None:
+    """Parse 16 raw bytes into an SCMPlus message.
+
+    Returns None if the packet fails CRC, has an invalid ProtocolID, or
+    has a zero EndpointID.
+    """
+    if len(raw) < 16:
+        return None
+    if not crc.valid(raw[:16]):
+        return None
+
+    frame_sync, protocol_id, endpoint_type, endpoint_id, consumption, tamper, packet_crc = (
+        _STRUCT.unpack(raw[:16])
+    )
+
+    if protocol_id != _PROTOCOL_ID or endpoint_id == 0:
+        return None
+
+    return SCMPlus(
+        frame_sync=frame_sync,
+        protocol_id=protocol_id,
+        endpoint_type=endpoint_type,
+        endpoint_id=endpoint_id,
+        consumption=consumption,
+        tamper=tamper,
+        packet_crc=packet_crc,
+    )

rtlamr_python/r900_decoder.py

@@ -0,0 +1,316 @@
+"""R900 signal processing pipeline.
+
+Port of rtlamr-go/r900/r900.go and rtlamr-go/r900/gf/gf.go.
+
+R900 uses a 4-chip/6-symbol encoding rather than Manchester coding:
+
+  Six symbols (each 4 chips):
+    0: 0011   3: 1100  (inverse of 0)
+    1: 0101   4: 1010  (inverse of 1)
+    2: 0110   5: 1001  (inverse of 2)
+
+A matched filter computes three correlation values per sample position,
+corresponding to the three base chip patterns.  The symbol with the highest
+absolute correlation value is selected; the sign determines whether it is
+the base (0-2) or inverted (3-5) form.
+
+Reed-Solomon verification over GF(32, polynomial=37, generator=2) is applied
+to the 21-symbol payload before field extraction.
+
+Preamble search uses the Manchester-quantized signal (same rolling-buffer
+architecture as the other decoders) since the R900 training sequence produces
+a predictable bit pattern through the Manchester filter.  The 4-chip filter
+is applied in parallel to the same magnitude signal, and the preamble hit
+indices from the Manchester pass are used to locate payloads in the 6-symbol
+quantized buffer.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import numpy as np
+
+from rtlamr_python.decoder import magnitude, matched_filter, _search, _next_power_of_2
+from rtlamr_python.protocols.r900 import R900, parse_bits, _R900_CENTER_FREQ
+
+# R900 protocol constants (from rtlamr-go/r900/r900.go)
+_DATA_RATE = 32_768
+_PREAMBLE_BITS = np.array(
+    [int(b) for b in "00000000000000001110010101100100"], dtype=np.uint8
+)
+_PREAMBLE_SYMBOLS = 32
+_PACKET_SYMBOLS = 116   # in Manchester-symbol units (ChipLength * 2 per symbol)
+_PAYLOAD_SYMBOLS = 42   # R900 4-chip symbols in the payload (21 pairs)
+
+
+# ---------------------------------------------------------------------------
+# Galois Field GF(32, 37, 2) — port of rtlamr-go/r900/gf/gf.go
+# ---------------------------------------------------------------------------
+
+class _GF:
+    """Galois Field arithmetic for Reed-Solomon syndrome computation."""
+
+    def __init__(self, order: int, poly: int, alpha: int) -> None:
+        n = order - 1
+        self._n = n
+        log = [0] * order
+        exp = [0] * (2 * n)
+        x = 1
+        for i in range(n):
+            exp[i] = x
+            exp[i + n] = x
+            log[x] = i
+            x = self._mul_gf(x, alpha, order, poly)
+        log[0] = n
+        self._log = log
+        self._exp = exp
+
+    @staticmethod
+    def _mul_gf(x: int, y: int, order: int, poly: int) -> int:
+        z = 0
+        while x > 0:
+            if x & 1:
+                z ^= y
+            x >>= 1
+            y <<= 1
+            if y & order:
+                y ^= poly
+        return z
+
+    def exp(self, e: int) -> int:
+        if e < 0:
+            return 0
+        return self._exp[e % self._n]
+
+    def log(self, x: int) -> int:
+        return -1 if x == 0 else self._log[x]
+
+    def mul(self, x: int, y: int) -> int:
+        if x == 0 or y == 0:
+            return 0
+        return self._exp[self._log[x] + self._log[y]]
+
+    def syndrome(self, message: list[int], parity_count: int, offset: int) -> list[int]:
+        result = []
+        for i in range(parity_count):
+            syn = message[0]
+            for v in message[1:]:
+                syn = self.mul(syn, self.exp(offset + i)) ^ v
+            result.append(syn)
+        return result
+
+
+_GF32 = _GF(32, 37, 2)
+
+
+# ---------------------------------------------------------------------------
+# 4-chip matched filter for R900
+# ---------------------------------------------------------------------------
+
+def _r900_filter(signal: np.ndarray, chip_length: int) -> np.ndarray:
+    """Compute the 3-value 4-chip matched filter output.
+
+    Returns shape (N, 3) where each row is [f0, f1, f2] corresponding to
+    the three base chip patterns: 1100, 1010, 1001.
+    """
+    cl = chip_length
+    n = len(signal) - 4 * cl + 1
+    if n <= 0:
+        return np.zeros((0, 3), dtype=np.float64)
+
+    csum = np.empty(len(signal) + 1, dtype=np.float64)
+    csum[0] = 0.0
+    np.cumsum(signal, out=csum[1:])
+
+    c0 = csum[:n]
+    c1 = csum[cl: cl + n] * 2
+    c2 = csum[2 * cl: 2 * cl + n] * 2
+    c3 = csum[3 * cl: 3 * cl + n] * 2
+    c4 = csum[4 * cl: 4 * cl + n]
+
+    f = np.empty((n, 3), dtype=np.float64)
+    f[:, 0] = c2 - c4 - c0           # 1100
+    f[:, 1] = c1 - c2 + c3 - c4 - c0  # 1010
+    f[:, 2] = c1 - c3 + c4 - c0      # 1001
+    return f
+
+
+def _r900_quantize(filtered: np.ndarray) -> np.ndarray:
+    """Map each filtered row to a 6-symbol value (0-5)."""
+    abs_f = np.abs(filtered)
+    argmax = np.argmax(abs_f, axis=1).astype(np.uint8)
+    signs = filtered[np.arange(len(filtered)), argmax]
+    quantized = argmax.copy()
+    quantized[signs > 0] += 3
+    return quantized
+
+
+# ---------------------------------------------------------------------------
+# R900Decoder
+# ---------------------------------------------------------------------------
+
+class R900Decoder:
+    """Stateful R900 decoder.
+
+    Architecture mirrors Decoder but maintains two parallel signal chains:
+      - Manchester chain: preamble search (same rolling-buffer logic)
+      - R900 4-chip chain: payload symbol extraction
+
+    Both are shifted by block_size each call, keeping them in sync so that
+    a preamble hit index from the Manchester chain maps to the same position
+    in the R900 quantized buffer.
+    """
+
+    def __init__(self, chip_length: int = 72) -> None:
+        chip = chip_length
+        sym = chip * 2  # Manchester symbol length
+
+        preamble_len = _PREAMBLE_SYMBOLS * sym
+        packet_len = _PACKET_SYMBOLS * sym
+        block_size = _next_power_of_2(preamble_len)
+        buf_len = packet_len + block_size
+
+        self._chip = chip
+        self._sym = sym
+        self._block_size = block_size
+        self._preamble_len = preamble_len
+        self._packet_len = packet_len
+        self._buf_len = buf_len
+        self.center_freq = _R900_CENTER_FREQ
+        self.sample_rate = _DATA_RATE * chip
+        self.block_size2 = block_size * 2
+
+        # Manchester chain (for preamble search)
+        self._man_signal = np.zeros(block_size + sym, dtype=np.float64)
+        self._man_quantized = np.zeros(buf_len, dtype=np.uint8)
+
+        # R900 signal chain
+        # block_size extra samples at the front so the rolling shift can read
+        # buf_len elements starting at block_size without going out of bounds.
+        # The chip*4 tail provides filter continuity beyond buf_len.
+        self._r900_signal = np.zeros(block_size + buf_len + chip * 4, dtype=np.float64)
+        self._r900_quantized = np.zeros(buf_len, dtype=np.uint8)
+
+        self._prev_seen: set[str] = set()
+        self._next_seen: set[str] = set()
+
+    def reset(self) -> None:
+        """Zero rolling buffers and clear dedup sets. Call after an SDR retune."""
+        self._man_signal[:] = 0
+        self._man_quantized[:] = 0
+        self._r900_signal[:] = 0
+        self._r900_quantized[:] = 0
+        self._prev_seen.clear()
+        self._next_seen.clear()
+
+    def decode(self, raw_block: bytes) -> list[R900]:
+        chip = self._chip
+        sym = self._sym
+        block_size = self._block_size
+        preamble_len = self._preamble_len
+        packet_len = self._packet_len
+        buf_len = self._buf_len
+
+        block = np.frombuffer(raw_block, dtype=np.uint8)
+        mag = magnitude(block)  # block_size2 bytes → block_size magnitude samples
+
+        # --- Manchester chain (preamble search) ---
+        self._man_signal[:sym] = self._man_signal[block_size:]
+        self._man_signal[sym:] = mag
+        filt_man = matched_filter(self._man_signal, chip)[:block_size]
+        self._man_quantized[:packet_len] = self._man_quantized[block_size:]
+        self._man_quantized[packet_len:] = filt_man
+
+        # --- R900 4-chip chain (payload decoding) ---
+        # Roll the signal buffer left by block_size.  The buffer is
+        # (block_size + buf_len + chip*4) samples wide so [block_size:] has exactly
+        # (buf_len + chip*4) elements — the same count as [:-block_size].
+        # New magnitudes fill position [packet_len:packet_len+block_size] so that
+        # _r900_signal[packet_len+k] == mag[k], matching the Manchester chain's
+        # alignment (_man_quantized[packet_len+k] also comes from mag[k]).
+        self._r900_signal[:-block_size] = self._r900_signal[block_size:]
+        self._r900_signal[packet_len: packet_len + block_size] = mag
+
+        r900_filt = _r900_filter(self._r900_signal[:buf_len + chip * 4], chip)
+        r900_q = _r900_quantize(r900_filt)
+        # Trim to buf_len to match the rolling buffer size.
+        self._r900_quantized[:] = r900_q[:buf_len]
+
+        # --- Preamble search in Manchester-quantized buffer ---
+        # Fake a minimal Config-like object for _search.
+        cfg = _SearchCfg(block_size, preamble_len, sym, _PREAMBLE_SYMBOLS)
+        indices = _search(self._man_quantized, _PREAMBLE_BITS, cfg)
+
+        self._next_seen.clear()
+        messages: list[R900] = []
+
+        for idx in indices:
+            if idx > block_size:
+                continue
+
+            # Payload starts after the 32-symbol preamble in the 4-chip quantized
+            # stream.  The index into the Manchester buffer maps to the same
+            # position in the R900 buffer since both shift by block_size each call.
+            # Adjust: preamble_len samples → skip preamble, subtract one sym for
+            # alignment (matches Go: payloadIdx = pkt.Idx + preambleLength - SymbolLength).
+            payload_idx = idx + preamble_len - sym
+
+            # Extract 42 symbols (21 pairs) at 4-chip intervals.
+            symbols: list[int] = []
+            for k in range(_PAYLOAD_SYMBOLS):
+                q_idx = payload_idx + k * chip * 4
+                if q_idx >= buf_len:
+                    break
+                symbols.append(int(self._r900_quantized[q_idx]))
+            if len(symbols) < _PAYLOAD_SYMBOLS:
+                continue
+
+            # Convert pairs of base-6 symbols to base-6 digit string.
+            digits = "".join(str(s) for s in symbols)
+
+            # Decode symbol pairs into 5-bit GF(32) elements.
+            gf_symbols: list[int] = []
+            bad = False
+            bits_str = ""
+            for k in range(0, len(digits), 2):
+                val = int(digits[k: k + 2], 6)
+                if val > 31:
+                    bad = True
+                    break
+                gf_symbols.append(val)
+                bits_str += f"{val:05b}"
+            if bad:
+                continue
+
+            # Reed-Solomon check: 5 parity symbols at positions 26-30 (offset 29).
+            rs_buf = [0] * 31
+            rs_buf[:16] = gf_symbols[:16]
+            rs_buf[26:] = gf_symbols[16:]
+            syndromes = _GF32.syndrome(rs_buf, 5, 29)
+            if any(s != 0 for s in syndromes):
+                continue
+
+            if digits in self._prev_seen or digits in self._next_seen:
+                continue
+            self._next_seen.add(digits)
+
+            msg = parse_bits(bits_str)
+            if msg is None:
+                continue
+            messages.append(msg)
+
+        self._prev_seen, self._next_seen = self._next_seen, self._prev_seen
+        return messages
+
+
+class _SearchCfg:
+    """Minimal duck-typed Config for _search()."""
+    __slots__ = ("block_size", "preamble_length", "symbol_length", "preamble_symbols")
+
+    def __init__(self, block_size: int, preamble_length: int, symbol_length: int, preamble_symbols: int) -> None:
+        self.block_size = block_size
+        self.preamble_length = preamble_length
+        self.symbol_length = symbol_length
+        self.preamble_symbols = preamble_symbols