cortexforge 0.1.0__py3-none-any.whl

cortexforge/forge/radio/tx_burst.py

@@ -0,0 +1,107 @@
+import numpy as np
+import pmt
+import math
+from gnuradio import gr, uhd
+
+
+class BurstScheduler(gr.sync_block):
+    """
+    Sort un flux complexe et place des tags UHD:
+    - tx_time (PMT tuple (int_secs, frac_secs)) au 1er sample du burst
+    - tx_sob au 1er sample
+    - tx_eob au dernier sample
+    """
+
+    def __init__(self, events, sample_rate, amplitude_scale=1.0):
+        gr.sync_block.__init__(
+            self,
+            name="BurstScheduler",
+            in_sig=None,
+            out_sig=[np.complex64],
+        )
+        self.events = list(events)
+        self.fs = float(sample_rate)
+        self.amp_scale = float(amplitude_scale)
+
+        # Pré-génère tous les bursts
+        self.bursts = []
+        for ev in self.events:
+            iq = ev["iq"].astype(np.complex64) * self.amp_scale
+            t0 = float(ev["t_start_s"])
+            self.bursts.append((t0, iq))
+
+        self.cur_idx = 0
+        self.cur_pos = 0
+        self.finished = False
+
+    def _tag_tx_time(self, abs_offset, t0_s):
+        # UHD attend tx_time = (int_secs, frac_secs)
+        int_s = int(math.floor(t0_s))
+        frac_s = float(t0_s - int_s)
+        key = pmt.intern("tx_time")
+        val = pmt.make_tuple(pmt.from_long(int_s), pmt.from_double(frac_s))
+        self.add_item_tag(0, abs_offset, key, val)
+
+    def _tag_flag(self, abs_offset, key_str):
+        self.add_item_tag(0, abs_offset, pmt.intern(key_str), pmt.PMT_T)
+
+    def work(self, input_items, output_items):
+        out = output_items[0]
+        n = len(out)
+        out[:] = 0
+
+        if self.finished:
+            return -1  # Fin de flux
+
+        produced = 0
+        while produced < n and not self.finished:
+            if self.cur_idx >= len(self.bursts):
+                self.finished = True
+                break
+
+            t0_s, iq = self.bursts[self.cur_idx]
+
+            # Premier sample du burst -> tags SOB + tx_time
+            if self.cur_pos == 0:
+                abs_off = self.nitems_written(0) + produced
+                self._tag_tx_time(abs_off, t0_s)
+                self._tag_flag(abs_off, "tx_sob")
+
+            remaining = len(iq) - self.cur_pos
+            space = n - produced
+            k = min(remaining, space)
+
+            out[produced : produced + k] = iq[self.cur_pos : self.cur_pos + k]
+            self.cur_pos += k
+            produced += k
+
+            # Dernier sample du burst -> tag EOB sur ce sample
+            if self.cur_pos >= len(iq):
+                abs_off_last = self.nitems_written(0) + produced - 1
+                self._tag_flag(abs_off_last, "tx_eob")
+                self.cur_idx += 1
+                self.cur_pos = 0
+
+        return produced
+
+
+class TxTimeline(gr.top_block):
+    def __init__(self, usrp_args, rate, center_freq, gain, events_with_iq):
+        super().__init__("TxTimeline")
+
+        self.sink = uhd.usrp_sink(
+            usrp_args,
+            uhd.stream_args(cpu_format="fc32", channels=[0]),
+        )
+
+        self.sink.set_clock_source("external", 0)
+        self.sink.set_time_source("external", 0)
+
+        self.sink.set_samp_rate(rate)
+        self.sink.set_center_freq(center_freq, 0)
+        self.sink.set_gain(gain, 0)
+        self.sink.set_antenna("TX/RX", 0)
+
+        self.src = BurstScheduler(events_with_iq, sample_rate=rate)
+
+        self.connect(self.src, self.sink)

cortexforge/forge/radio/waveforms.py

@@ -0,0 +1,42 @@
+from cortexforge.forge.radio.waveforms_analog import make_analog_burst
+from cortexforge.forge.radio.waveforms_numerique import make_digital_burst
+
+MODULATION_ALIASES = {
+    "32QAM": "32QAM_RECT",
+    "128QAM": "128QAM_RECT",
+    "4PAM": "PAM4",
+}
+
+ANALOG_MODULATIONS = {"AM-DSB", "AM-SSB", "FM"}
+
+
+def make_burst(
+    modulation: str,
+    sample_rate: float,
+    symbol_rate: float,
+    duration_s: float,
+    rolloff: float,
+    amplitude: float,
+    span_symbols: int = 11,
+):
+    modulation = MODULATION_ALIASES.get(modulation.upper(), modulation.upper())
+    if modulation in ANALOG_MODULATIONS:
+        return make_analog_burst(
+            modulation=modulation,
+            sample_rate=sample_rate,
+            symbol_rate=symbol_rate,
+            duration_s=duration_s,
+            rolloff=rolloff,
+            amplitude=amplitude,
+            span_symbols=span_symbols,
+        )
+
+    return make_digital_burst(
+        modulation=modulation,
+        sample_rate=sample_rate,
+        symbol_rate=symbol_rate,
+        duration_s=duration_s,
+        rolloff=rolloff,
+        amplitude=amplitude,
+        span_symbols=span_symbols,
+    )

cortexforge/forge/radio/waveforms_analog.py

@@ -0,0 +1,85 @@
+import numpy as np
+
+from cortexforge.forge.radio.waveforms_numerique import rrc_taps
+
+
+def _analytic_signal(x: np.ndarray) -> np.ndarray:
+    n = len(x)
+    X = np.fft.fft(x.astype(np.float32))
+    h = np.zeros(n, dtype=np.float32)
+
+    if n % 2 == 0:
+        h[0] = 1.0
+        h[n // 2] = 1.0
+        h[1 : n // 2] = 2.0
+    else:
+        h[0] = 1.0
+        h[1 : (n + 1) // 2] = 2.0
+
+    return np.fft.ifft(X * h).astype(np.complex64)
+
+
+def _make_message(
+    sample_rate: float,
+    symbol_rate: float,
+    duration_s: float,
+    rolloff: float,
+    span_symbols: int,
+) -> np.ndarray:
+    sps = int(round(sample_rate / symbol_rate))
+    if sps < 2:
+        raise ValueError(
+            f"sps too small (sample_rate/symbol_rate={sample_rate / symbol_rate:.2f}). Increase sample_rate or decrease symbol_rate."
+        )
+
+    nsamp = int(round(duration_s * sample_rate))
+    nsyms = int(np.ceil(nsamp / sps))
+
+    rng = np.random.default_rng()
+    msg_syms = rng.uniform(-1.0, 1.0, size=nsyms).astype(np.float32)
+
+    up = np.zeros(nsyms * sps, dtype=np.float32)
+    up[::sps] = msg_syms
+    taps = rrc_taps(rolloff, sps, span_symbols)
+    shaped = np.convolve(up, taps, mode="same")[:nsamp]
+
+    peak = np.max(np.abs(shaped))
+    if peak > 0:
+        shaped /= peak
+    return shaped.astype(np.float32)
+
+
+def make_analog_burst(
+    modulation: str,
+    sample_rate: float,
+    symbol_rate: float,
+    duration_s: float,
+    rolloff: float,
+    amplitude: float,
+    span_symbols: int,
+) -> np.ndarray:
+    msg = _make_message(
+        sample_rate=sample_rate,
+        symbol_rate=symbol_rate,
+        duration_s=duration_s,
+        rolloff=rolloff,
+        span_symbols=span_symbols,
+    )
+
+    if modulation == "AM-DSB":
+        carrier_leak = 0.5
+        burst = (carrier_leak + 0.5 * msg).astype(np.complex64)
+    elif modulation == "AM-SSB":
+        burst = _analytic_signal(msg)
+        peak = np.max(np.abs(burst))
+        if peak > 0:
+            burst /= peak
+    elif modulation == "FM":
+        freq_dev_hz = min(symbol_rate * 0.25, sample_rate * 0.20)
+        phase = 2 * np.pi * freq_dev_hz * np.cumsum(msg, dtype=np.float64) / sample_rate
+        burst = np.exp(1j * phase).astype(np.complex64)
+    else:
+        raise ValueError(f"Unsupported analog modulation: {modulation}")
+
+    burst *= float(amplitude)
+    return burst.astype(np.complex64)

cortexforge/forge/radio/waveforms_numerique.py

@@ -0,0 +1,247 @@
+import numpy as np
+
+
+def rrc_taps(beta: float, sps: int, span: int) -> np.ndarray:
+    """
+    Root Raised Cosine taps.
+    span: in symbols (total taps = span*sps + 1)
+    """
+    N = span * sps
+    t = np.arange(-N / 2, N / 2 + 1) / sps
+    taps = np.zeros_like(t, dtype=np.float64)
+
+    for i, ti in enumerate(t):
+        if abs(ti) < 1e-12:
+            taps[i] = 1.0 - beta + (4 * beta / np.pi)
+        elif beta > 0 and abs(abs(4 * beta * ti) - 1.0) < 1e-12:
+            # t = +- 1/(4beta)
+            taps[i] = (beta / np.sqrt(2)) * (
+                (1 + 2 / np.pi) * np.sin(np.pi / (4 * beta))
+                + (1 - 2 / np.pi) * np.cos(np.pi / (4 * beta))
+            )
+        else:
+            num = np.sin(np.pi * ti * (1 - beta)) + 4 * beta * ti * np.cos(
+                np.pi * ti * (1 + beta)
+            )
+            den = np.pi * ti * (1 - (4 * beta * ti) ** 2)
+            taps[i] = num / den
+
+    taps /= np.sqrt(np.sum(taps**2) + 1e-12)
+    return taps.astype(np.float32)
+
+
+def bits(rng, nbits: int) -> np.ndarray:
+    return rng.integers(0, 2, size=nbits, dtype=np.int8)
+
+
+def _pam_gray_levels(nbits: int) -> np.ndarray:
+    levels = np.arange(-(2**nbits - 1), 2**nbits, 2, dtype=np.float32)
+    gray = np.arange(2**nbits, dtype=np.int32) ^ (np.arange(2**nbits, dtype=np.int32) >> 1)
+    return levels[gray]
+
+
+def _bits_to_int(bb: np.ndarray) -> np.ndarray:
+    weights = (1 << np.arange(bb.shape[1] - 1, -1, -1)).astype(np.int32)
+    return (bb.astype(np.int32) * weights).sum(axis=1)
+
+
+def _psk_symbols(b: np.ndarray, bits_per_symbol: int) -> np.ndarray:
+    idx = _bits_to_int(b.reshape(-1, bits_per_symbol))
+    phase = 2 * np.pi * idx / (2**bits_per_symbol)
+    return np.exp(1j * phase).astype(np.complex64)
+
+
+def _qam_symbols(b: np.ndarray, i_bits: int, q_bits: int) -> np.ndarray:
+    b = b.reshape(-1, i_bits + q_bits)
+    i_levels = _pam_gray_levels(i_bits)
+    q_levels = _pam_gray_levels(q_bits)
+    i = i_levels[_bits_to_int(b[:, :i_bits])]
+    q = q_levels[_bits_to_int(b[:, i_bits:])]
+    x = i + 1j * q
+    x /= np.sqrt(np.mean(np.abs(x) ** 2))
+    return x.astype(np.complex64)
+
+
+def _cross_qam_constellation(grid_size: int, corner_levels_to_remove: int) -> np.ndarray:
+    levels = np.arange(-(grid_size - 1), grid_size, 2, dtype=np.float32)
+    corner_threshold = grid_size - 2 * corner_levels_to_remove
+    constellation = np.array(
+        [
+            i + 1j * q
+            for q in levels
+            for i in levels
+            if not (abs(i) >= corner_threshold and abs(q) >= corner_threshold)
+        ],
+        dtype=np.complex64,
+    )
+    return constellation
+
+
+def _cross_qam_symbols(
+    b: np.ndarray,
+    bits_per_symbol: int,
+    grid_size: int,
+    corner_levels_to_remove: int,
+) -> np.ndarray:
+    b = b.reshape(-1, bits_per_symbol)
+    constellation = _cross_qam_constellation(grid_size, corner_levels_to_remove)
+
+    idx = _bits_to_int(b)
+    x = constellation[idx].astype(np.complex64)
+    x /= np.sqrt(np.mean(np.abs(x) ** 2))
+    return x.astype(np.complex64)
+
+
+def _cross_32qam_symbols(b: np.ndarray) -> np.ndarray:
+    return _cross_qam_symbols(b, bits_per_symbol=5, grid_size=6, corner_levels_to_remove=1)
+
+
+def _cross_128qam_symbols(b: np.ndarray) -> np.ndarray:
+    return _cross_qam_symbols(b, bits_per_symbol=7, grid_size=12, corner_levels_to_remove=2)
+
+
+def _ask_symbols(b: np.ndarray, bits_per_symbol: int) -> np.ndarray:
+    if bits_per_symbol == 1:
+        return b.astype(np.complex64)
+
+    levels = _pam_gray_levels(bits_per_symbol)
+    x = levels[_bits_to_int(b.reshape(-1, bits_per_symbol))].astype(np.float32)
+    x /= np.sqrt(np.mean(np.abs(x) ** 2))
+    return x.astype(np.complex64)
+
+
+def _gaussian_taps(bt: float, sps: int, span: int) -> np.ndarray:
+    """
+    Unit-area Gaussian filter taps for GFSK frequency pulse shaping.
+    """
+    n = span * sps
+    t = np.arange(-n / 2, n / 2 + 1, dtype=np.float64) / sps
+    alpha = np.sqrt(2 * np.pi) * bt / np.sqrt(np.log(2))
+    taps = np.exp(-2 * (np.pi**2) * (alpha**2) * (t**2)).astype(np.float64)
+    taps /= np.sum(taps) + 1e-12
+    return taps.astype(np.float32)
+
+
+def _cpfsk_like_burst(
+    symbols: np.ndarray,
+    sps: int,
+    nsamp: int,
+    amplitude: float,
+    modulation_index: float,
+    gaussian_bt: float | None = None,
+    gaussian_span: int = 4,
+) -> np.ndarray:
+    up = np.repeat(symbols.astype(np.float32), sps)
+
+    if gaussian_bt is not None:
+        freq_pulse = np.convolve(
+            up,
+            _gaussian_taps(gaussian_bt, sps, gaussian_span),
+            mode="same",
+        )
+    else:
+        freq_pulse = up
+
+    phase = np.cumsum(freq_pulse, dtype=np.float64) * (np.pi * modulation_index / sps)
+    burst = np.exp(1j * phase[:nsamp]).astype(np.complex64)
+    burst *= float(amplitude)
+    return burst.astype(np.complex64)
+
+
+def map_symbols(mod: str, b: np.ndarray) -> np.ndarray:
+    if mod == "OOK":
+        return _ask_symbols(b, 1)
+    if mod == "PAM4":
+        return _ask_symbols(b, 2)
+    if mod == "4ASK":
+        return _ask_symbols(b, 2)
+    if mod == "8ASK":
+        return _ask_symbols(b, 3)
+    if mod == "BPSK":
+        return _psk_symbols(b, 1)
+    if mod == "QPSK":
+        return _psk_symbols(b, 2)
+    if mod == "8PSK":
+        return _psk_symbols(b, 3)
+    if mod == "16PSK":
+        return _psk_symbols(b, 4)
+    if mod == "32PSK":
+        return _psk_symbols(b, 5)
+    if mod == "16QAM":
+        return _qam_symbols(b, 2, 2)
+    if mod == "32QAM_RECT":
+        return _qam_symbols(b, 3, 2)
+    if mod == "32QAM_CROSS":
+        return _cross_32qam_symbols(b)
+    if mod == "64QAM":
+        return _qam_symbols(b, 3, 3)
+    if mod == "128QAM_RECT":
+        return _qam_symbols(b, 4, 3)
+    if mod == "128QAM_CROSS":
+        return _cross_128qam_symbols(b)
+    if mod == "256QAM":
+        return _qam_symbols(b, 4, 4)
+    raise ValueError(f"Unsupported modulation: {mod}")
+
+
+def make_digital_burst(
+    modulation: str,
+    sample_rate: float,
+    symbol_rate: float,
+    duration_s: float,
+    rolloff: float,
+    amplitude: float,
+    span_symbols: int,
+) -> np.ndarray:
+    sps = int(round(sample_rate / symbol_rate))
+    if sps < 2:
+        raise ValueError(
+            f"sps too small (sample_rate/symbol_rate={sample_rate / symbol_rate:.2f}). Increase sample_rate or decrease symbol_rate."
+        )
+
+    nsamp = int(round(duration_s * sample_rate))
+    nsyms = int(np.ceil(nsamp / sps))
+
+    rng = np.random.default_rng()
+    if modulation in {"CPFSK", "GFSK"}:
+        b = bits(rng, nsyms)
+        symbols = (2 * b.astype(np.float32)) - 1.0
+        gaussian_bt = 0.35 if modulation == "GFSK" else None
+        return _cpfsk_like_burst(
+            symbols=symbols,
+            sps=sps,
+            nsamp=nsamp,
+            amplitude=amplitude,
+            modulation_index=0.5,
+            gaussian_bt=gaussian_bt,
+        )
+
+    bps = {
+        "OOK": 1,
+        "PAM4": 2,
+        "4ASK": 2,
+        "8ASK": 3,
+        "BPSK": 1,
+        "QPSK": 2,
+        "8PSK": 3,
+        "16PSK": 4,
+        "32PSK": 5,
+        "16QAM": 4,
+        "32QAM_RECT": 5,
+        "32QAM_CROSS": 5,
+        "64QAM": 6,
+        "128QAM_RECT": 7,
+        "128QAM_CROSS": 7,
+        "256QAM": 8,
+    }[modulation]
+    b = bits(rng, nsyms * bps)
+    syms = map_symbols(modulation, b)
+
+    up = np.zeros(nsyms * sps, dtype=np.complex64)
+    up[::sps] = syms
+    taps = rrc_taps(rolloff, sps, span_symbols)
+    shaped = np.convolve(up, taps.astype(np.complex64), mode="same")
+
+    burst = shaped[:nsamp]
+    burst *= float(amplitude)
+    return burst.astype(np.complex64)

cortexforge/forge/utils/compute_baseline.py

@@ -0,0 +1,64 @@
+import numpy as np
+import math
+
+
+MIN_LINEAR_POWER = np.finfo(np.float32).tiny
+
+
+def _dbfs_from_mean_power(mean_power):
+    return 10.0 * math.log10(max(float(mean_power), MIN_LINEAR_POWER) / 2.0)
+
+
+def measure_window_power(path, sample_start, sample_count):
+    """
+    Measure the average power of a complex float32 IQ window.
+
+    Returns a dictionary describing the effective measured window.
+    """
+    if sample_count <= 0:
+        raise ValueError("sample_count must be strictly positive")
+
+    offset_bytes = int(sample_start) * 2 * np.dtype(np.float32).itemsize
+    count_iq = int(sample_count) * 2
+
+    x = np.fromfile(path, dtype=np.float32, count=count_iq, offset=offset_bytes)
+    if x.size < 2:
+        raise ValueError("window contains no IQ samples")
+
+    i = x[0::2]
+    q = x[1::2]
+    effective_samples = min(i.size, q.size)
+    if effective_samples == 0:
+        raise ValueError("window contains incomplete IQ samples")
+
+    mean_power = float(np.mean(i[:effective_samples] * i[:effective_samples] + q[:effective_samples] * q[:effective_samples]))
+
+    return {
+        "sample_start": int(sample_start),
+        "sample_count": int(effective_samples),
+        "mean_power": mean_power,
+        "power_dbfs": _dbfs_from_mean_power(mean_power),
+    }
+
+
+def compute_baseline(path, sample_rate, skip=0.5, win_size=1.0):
+    """
+    Compute the baseline (noise mean) of the given data between skip and skip + win_size in seconds.
+
+    Parameters:
+    path: The input data for which to compute the baseline.
+    sample_rate: The sample rate of the data in samples per second.
+
+    Returns:
+    float: The computed baseline value.
+    """
+    skip_samples = int(skip * sample_rate)
+    win_samples = int(win_size * sample_rate)
+    stats = measure_window_power(path, sample_start=skip_samples, sample_count=win_samples)
+
+    return {
+        "skip_samples": skip_samples,
+        "win_samples": stats["sample_count"],
+        "mean_power": stats["mean_power"],
+        "power_dbfs": stats["power_dbfs"],
+    }

cortexforge/forge/utils/load_timeline.py

@@ -0,0 +1,36 @@
+import csv
+from typing import Any, Dict, List
+
+
+def load_timeline(path: str) -> List[Dict[str, Any]]:
+    """
+    Load a TX timeline CSV file.
+
+    Returns
+    -------
+    events : list of dict
+        Each dict contains the parsed parameters for one TX event.
+    """
+    events = []
+
+    with open(path, newline="") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            event = {
+                "radio": row["radio"],
+                "t_start_s": float(row["start_time"]),
+                "duration_s": float(row["duration_s"]),
+                "sample_rate_sps": int(row["sample_rate_sps"]),
+                "amplitude": float(row["amplitude"]),
+                "modulation": row["modulation"],
+                "symbol_rate": float(row["symbol_rate"]),
+                "rolloff": float(row["roll_off"]),
+            }
+            if row.get("freq_hz") not in (None, ""):
+                event["freq_hz"] = int(row["freq_hz"])
+            if row.get("tx_gain_db") not in (None, ""):
+                event["tx_gain_db"] = float(row["tx_gain_db"])
+            events.append(event)
+
+    events.sort(key=lambda e: e["t_start_s"])
+    return events

cortexforge/forge/utils/node_identity.py

@@ -0,0 +1,15 @@
+"""Get node name identity."""
+
+from socket import gethostname
+from logging import getLogger
+
+logger = getLogger(__name__)
+
+
+def get_node_name() -> str:
+    try:
+        hostname = gethostname()
+        return hostname
+    except Exception as e:
+        logger.error(f"Error getting hostname: {e}")
+        return "unknown"

cortexforge/forge/utils/node_layout.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import math
+import re
+
+GRID_SPACING_M = 1.8
+
+_NODE_GRID = {
+    1: (0, 0), 3: (1, 0), 5: (2, 0), 7: (3, 0), 9: (4, 0),
+    11: (5, 0), 13: (6, 0), 15: (7, 0), 17: (8, 0), 19: (9, 0),
+
+    2: (0, 1), 4: (1, 1), 6: (2, 1), 8: (3, 1), 10: (4, 1),
+    12: (5, 1), 14: (6, 1), 16: (7, 1), 18: (8, 1), 20: (9, 1),
+
+    21: (0, 2), 23: (1, 2), 25: (2, 2), 27: (3, 2), 29: (4, 2),
+    31: (5, 2), 33: (6, 2), 35: (7, 2), 37: (8, 2), 39: (9, 2),
+
+    22: (0, 3), 24: (1, 3), 26: (2, 3), 28: (3, 3), 30: (4, 3),
+    32: (5, 3), 34: (6, 3), 36: (7, 3), 38: (8, 3), 40: (9, 3),
+}
+
+NODE_COORDS_M = {
+    node_id: (col * GRID_SPACING_M, row * GRID_SPACING_M)
+    for node_id, (col, row) in _NODE_GRID.items()
+}
+
+
+def parse_node_id(node_name: str) -> int:
+    match = re.search(r"(\d+)$", node_name)
+    if not match:
+        raise ValueError(f"Cannot extract node id from '{node_name}'")
+    return int(match.group(1))
+
+
+def get_node_coords_m(node_name: str) -> tuple[float, float]:
+    node_id = parse_node_id(node_name)
+    if node_id not in NODE_COORDS_M:
+        raise KeyError(f"Unknown node id: {node_id}")
+    return NODE_COORDS_M[node_id]
+
+
+def distance(tx_node: str, rx_node: str) -> float:
+    tx_x, tx_y = get_node_coords_m(tx_node)
+    rx_x, rx_y = get_node_coords_m(rx_node)
+    return round(math.hypot(tx_x - rx_x, tx_y - rx_y), 3)

cortexforge/forge/utils/sigmf/hash.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+import hashlib
+
+def _sha512_hex(path: Path, chunk_size: int = 1024 * 1024) -> str:
+    """Compute SHA-512 hash of a file and return it as a hex string."""
+    h = hashlib.sha512()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(chunk_size), b""):
+            h.update(chunk)
+    return h.hexdigest()