Радиозанавес (RF Curtain) — охрана периметра на просвет

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
РАДИОЗАНАВЕС — СИМУЛЯТОР для класса (без железа, без пары TX/RX).

Зачем нужен рядом с боевым rf_curtain.py: тот детектор требует живого линка
(две платы E77) или записанного лога. Этот стенд СИНТЕЗИРУЕТ поток RSSI —
человек «идёт» по сцене, пересекает луч, RSSI проседает и «кипит» ровно по
физике из Теория_RFCurtain.md (раздел 3), — и прогоняет ТОТ ЖЕ детектор с
двумя признаками. Ученик крутит пороги ползунками и сразу видит, что стало
с попаданиями и ложными тревогами. Урок «настрой детектор» (Writeup, опыт В)
можно провести за партой до выхода во двор.

Физика синтеза (всё из теории, раздел 3):
  * зона Френеля: r₁ = √(λ·d1·d2/d); человек перекрывает долю площади зоны в
    точке пересечения → просадка тем глубже, чем ближе к середине луча;
  * экранировка телом: до ~8–10 дБ поглощения на 869 МГц;
  * многолучёвка: движущееся тело перемешивает отражения → растёт РАЗБРОС
    (std) RSSI — второй признак «кипение», даже без большой просадки;
  * дрейф фона: медленный синус + шум, чтобы показать, зачем нужна ПЛАВАЮЩАЯ
    база, а не абсолютный порог.

Детектор — копия правила из rf_curtain.py: быстрая медиана (окно 0.5 c) против
медленной базы (EMA), тревога по просадке ИЛИ по кипению, база ЗАМОРАЖИВАЕТСЯ
на время тревоги (кнопка «Заморозка базы» выключает заморозку — учебный
анти-режим: нарушитель, постояв в луче, становится «новой нормой»).

Запуск:
    uv run rf_curtain_sim.py
Без uv:
    pip install numpy matplotlib && python rf_curtain_sim.py
"""

# /// script
# requires-python = ">=3.11"
# dependencies = ["numpy>=1.26", "matplotlib>=3.8"]
# ///

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.widgets import Slider, Button

# --- Параметры линка (1:1 с RFCurtain.ino / Теория раздел 3) ---
FREQ_MHZ = 869.400
C = 299_792_458.0
LAMBDA_M = C / (FREQ_MHZ * 1e6)     # ~0.345 м на 869 МГц
LINK_LEN_M = 10.0                   # расстояние TX↔RX
RSSI_BASE_DBM = -45.0               # «жирный» линк вблизи (стол/короткая дистанция)
BODY_ATTEN_DB = 9.0                 # поглощение телом при полном перекрытии зоны
PERSON_RADIO_M = 0.5                # «радиотень» человека
RATE_HZ = 15.0                      # частота пакетов занавеса
DUR_S = 40.0                        # длительность синтезируемой сессии

FAST_WIN_S = 0.5
TAU_BASE_S = 8.0                    # для класса база быстрее (короче сессия)
HOLD_S = 1.0
WARMUP_S = 4.0


def fresnel_radius_m(d1, d2):
    """Радиус первой зоны Френеля в точке, делящей линк на d1 и d2 (Теория 3)."""
    d = d1 + d2
    if d <= 0:
        return 0.0
    return np.sqrt(LAMBDA_M * d1 * d2 / d)


def synth_trace(seed, crossings):
    """
    Синтезирует (t, rssi) и список моментов пересечения (ground truth).
    crossings: список (t_center, где_вдоль_луча 0..1, скорость 'шаг'/'бег').
    """
    rng = np.random.default_rng(seed)
    n = int(DUR_S * RATE_HZ)
    t = np.arange(n) / RATE_HZ
    # фон: медленный дрейф (температура/фон) + белый шум измерения
    drift = 1.5 * np.sin(2 * np.pi * t / 25.0)
    rssi = RSSI_BASE_DBM + drift + rng.normal(0, 0.8, n)

    truth = []
    for (tc, pos, speed) in crossings:
        truth.append(tc)
        # ширина «ямы» во времени: бег короче шага
        width = 0.25 if speed == "бег" else 0.6
        # Глубина просадки. Основа — экранировка телом (BODY_ATTEN_DB). Она
        # максимальна в СЕРЕДИНЕ луча, где радиус зоны Френеля наибольший
        # (Теория 3): тело закрывает бОльшую долю «чувствительного объёма».
        # Ближе к антеннам зона узкая — тело проскакивает край, тень мельче.
        d1 = max(pos, 0.02) * LINK_LEN_M
        d2 = max(1.0 - pos, 0.02) * LINK_LEN_M
        r1 = fresnel_radius_m(d1, d2)
        r1_mid = fresnel_radius_m(LINK_LEN_M / 2, LINK_LEN_M / 2)
        centrality = r1 / r1_mid                 # 1.0 в центре, спадает к краям
        depth = BODY_ATTEN_DB * centrality
        env = np.exp(-0.5 * ((t - tc) / width) ** 2)          # гауссова «яма»
        rssi -= depth * env
        # многолучёвка: во время прохода растёт РАЗБРОС (кипение)
        boil = rng.normal(0, 1.0, n) * (2.5 * env)
        rssi += boil
    return t, rssi, truth


def run_detector(t, rssi, drop_db, sigma_db, freeze_on):
    """Копия правила из rf_curtain.py. Возвращает (fast_md, base, sigma, events)."""
    fast_md = np.zeros_like(rssi)
    base_arr = np.zeros_like(rssi)
    sig_arr = np.zeros_like(rssi)
    baseline = None
    alarm_active = False
    alarm_until = 0.0
    events = []          # [t_start, t_end|None, kind]

    from collections import deque
    fast_buf = deque()
    for i, (ti, ri) in enumerate(zip(t, rssi)):
        fast_buf.append((ti, ri))
        while fast_buf and ti - fast_buf[0][0] > FAST_WIN_S:
            fast_buf.popleft()
        vals = np.array([v for _, v in fast_buf])
        fmd = float(np.median(vals))
        fsd = float(np.std(vals)) if len(vals) >= 3 else 0.0

        if baseline is None:
            baseline = fmd
        freeze = alarm_active and freeze_on
        if not freeze:
            dt = (ti - t[i - 1]) if i > 0 else 1.0 / RATE_HZ
            a = min(1.0, dt / TAU_BASE_S)
            baseline += a * (fmd - baseline)

        warm = ti >= WARMUP_S
        drop = (baseline - fmd) >= drop_db
        boil = fsd >= sigma_db
        if warm and (drop or boil):
            if not alarm_active:
                events.append([ti, None, "drop" if drop else "boil"])
            alarm_active = True
            alarm_until = ti + HOLD_S
        elif alarm_active and ti > alarm_until:
            alarm_active = False
            events[-1][1] = ti

        fast_md[i] = fmd
        base_arr[i] = baseline
        sig_arr[i] = fsd
    if events and events[-1][1] is None:
        events[-1][1] = t[-1]
    return fast_md, base_arr, sig_arr, events


def score(events, truth):
    """ROC-подсчёт: попадания (тревога рядом с пересечением ±1 c) и ложные."""
    hits = 0
    matched = [False] * len(events)
    for tm in truth:
        for k, (a, b, _) in enumerate(events):
            if a - 1.0 <= tm <= (b or tm) + 1.0:
                hits += 1
                matched[k] = True
                break
    false_alarms = sum(1 for k, m in enumerate(matched) if not m)
    misses = len(truth) - hits
    return hits, misses, false_alarms


def main():
    # Сценарий: пересечение шагом в середине, пробежка сбоку (провокация),
    # пересечение бегом ближе к RX. Судья «отмечает» только реальные пересечения.
    crossings = [(10.0, 0.5, "шаг"), (20.0, 0.5, "бег"), (30.0, 0.75, "шаг")]
    provocation_only = 25.0   # «кипение» рядом с лучом без пересечения — НЕ ground truth
    st = {"seed": 1, "drop": 3.0, "sigma": 2.5, "freeze": True}

    fig = plt.figure(figsize=(12, 8))
    plt.style.use("default")
    fig.suptitle("Радиозанавес — СИМУЛЯТОР: тень человека в зоне Френеля + детектор",
                 fontsize=13, fontweight="bold")
    ax1 = fig.add_axes([0.08, 0.62, 0.88, 0.28])
    ax2 = fig.add_axes([0.08, 0.44, 0.88, 0.14])
    ax3 = fig.add_axes([0.08, 0.26, 0.88, 0.14])

    def redraw(_=None):
        t, rssi, truth = synth_trace(st["seed"], crossings)
        # добавим «провокацию» (кипение без просадки) — не в truth
        rng = np.random.default_rng(st["seed"] + 100)
        env = np.exp(-0.5 * ((t - provocation_only) / 0.7) ** 2)
        rssi = rssi + rng.normal(0, 1.0, len(t)) * (2.8 * env)

        fmd, base, sig, events = run_detector(t, rssi, st["drop"], st["sigma"], st["freeze"])
        hits, misses, fa = score(events, truth)

        for ax in (ax1, ax2, ax3):
            ax.clear()

        # --- верхний: сырьё + два сглаживания ---
        ax1.plot(t, rssi, ".", ms=2.5, color="#9aa5b1", alpha=0.6, label="сырой RSSI")
        ax1.plot(t, fmd, "-", lw=2, color="#0d9488", label="быстрая медиана (0.5 c)")
        ax1.plot(t, base, "--", lw=1.6, color="#d97706", label="медленная база (EMA)")
        for a, b, kind in events:
            ax1.axvspan(a, b, color="#ef4444" if kind == "drop" else "#f97316", alpha=0.18)
        for tm in truth:
            ax1.axvline(tm, color="#111", ls="--", lw=1.0, alpha=0.7)
        ax1.set_ylabel("RSSI, дБм")
        ax1.legend(loc="lower left", fontsize=8, framealpha=0.4)
        ax1.grid(alpha=0.25)
        fr = "заморозка ВКЛ" if st["freeze"] else "заморозка ВЫКЛ (анти-режим!)"
        ax1.set_title(f"Попаданий: {hits}/{len(truth)}  |  пропусков: {misses}  |  "
                      f"ложных: {fa}   ({fr})", fontsize=10)

        # --- средний: признак 1, просадка ---
        ax2.plot(t, fmd - base, "-", lw=1.5, color="#2563eb")
        ax2.axhline(-st["drop"], color="#ef4444", ls=":", lw=1.4)
        ax2.axhline(0, color="#999", lw=0.7)
        ax2.set_ylabel("медиана−база, дБ")
        ax2.grid(alpha=0.25)

        # --- нижний: признак 2, кипение ---
        ax3.plot(t, sig, "-", lw=1.5, color="#9333ea")
        ax3.axhline(st["sigma"], color="#ef4444", ls=":", lw=1.4)
        ax3.set_ylabel("кипение std, дБ")
        ax3.set_xlabel("время, c")
        ax3.grid(alpha=0.25)

        for ax in (ax1, ax2, ax3):
            ax.set_xlim(0, DUR_S)
        fig.canvas.draw_idle()

    ax_drop = fig.add_axes([0.14, 0.15, 0.5, 0.03])
    s_drop = Slider(ax_drop, "Порог просадки, дБ", 0.5, 8.0, valinit=st["drop"], valstep=0.5)
    ax_sig = fig.add_axes([0.14, 0.10, 0.5, 0.03])
    s_sig = Slider(ax_sig, "Порог кипения σ, дБ", 0.5, 6.0, valinit=st["sigma"], valstep=0.5)

    def on_drop(v): st["drop"] = v; redraw()
    def on_sig(v): st["sigma"] = v; redraw()
    s_drop.on_changed(on_drop)
    s_sig.on_changed(on_sig)

    ax_fr = fig.add_axes([0.72, 0.13, 0.22, 0.05])
    b_fr = Button(ax_fr, "Заморозка базы: ВКЛ/ВЫКЛ")
    def toggle_freeze(_): st["freeze"] = not st["freeze"]; redraw()
    b_fr.on_clicked(toggle_freeze)

    ax_new = fig.add_axes([0.72, 0.06, 0.22, 0.05])
    b_new = Button(ax_new, "Новая сессия (шум)")
    def reseed(_): st["seed"] += 1; redraw()
    b_new.on_clicked(reseed)

    redraw()
    plt.show()


if __name__ == "__main__":
    main()

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
РАДИОЗАНАВЕС — живой визуализатор и детектор (пара к RFCurtain.ino, роль RX).

Устройство глупое (льёт DATA,millis,seq,rssi,snr в консоль) — ВЕСЬ детектор
здесь, чтобы дети крутили пороги и ВИДЕЛИ на графике, что меняется.

Детектор (два признака, каждый — свой график):
  1) ПРОСАДКА: быстрая медиана (окно ~0.5 c) упала ниже медленной базы
     на drop_db децибел. База — EMA с постоянной времени tau_base секунд,
     и она ЗАМОРАЖИВАЕТСЯ на время тревоги: иначе нарушитель, постояв в
     луче, станет «новой нормой» и тревога снимется сама (классическая
     ошибка охранных систем — покажите её детям, выключив заморозку).
  2) КИПЕНИЕ: разброс (std) в быстром окне выше sigma_db — многолучёвка
     от движущегося тела заставляет сигнал «кипеть» даже без просадки.
  Плюс диагноз ОБРЫВ: пакетов нет дольше gap_s секунд — это НЕ нарушитель,
  это умер линк (питание TX, кто-то унёс антенну) — отдельный цвет.

Кнопка на RX-плате шлёт MARK — «отметка правды» (судья жмёт в момент
реального пересечения). На графике — вертикальная линия: честно считаем
попадания, пропуски и ложные тревоги.

Запуск (живой):   python3 rf_curtain.py --port /dev/ttyUSB0
Повтор из лога:   python3 rf_curtain.py --replay curtain_log.csv
Пороги на лету:   --drop-db 3.0 --sigma-db 2.5 --tau-base 60

Зависимости: pip install pyserial matplotlib numpy
"""

import argparse
import collections
import csv
import sys
import time

import numpy as np
import matplotlib
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

# ----------------------------- параметры CLI -----------------------------
ap = argparse.ArgumentParser(description="Радиозанавес: живой график + детектор")
ap.add_argument("--port", help="последовательный порт RX-платы, напр. /dev/ttyUSB0 или COM5")
ap.add_argument("--baud", type=int, default=115200)
ap.add_argument("--replay", help="не слушать порт, а проиграть CSV-лог")
ap.add_argument("--log", default=None, help="куда писать CSV-лог (по умолчанию curtain_YYYYmmdd_HHMMSS.csv)")
ap.add_argument("--drop-db", type=float, default=3.0, help="порог просадки от базы, дБ (default 3.0)")
ap.add_argument("--sigma-db", type=float, default=2.5, help="порог кипения (std быстрого окна), дБ (default 2.5)")
ap.add_argument("--fast-win", type=float, default=0.5, help="быстрое окно, c (default 0.5)")
ap.add_argument("--tau-base", type=float, default=60.0, help="постоянная времени базы, c (default 60)")
ap.add_argument("--hold-s", type=float, default=1.0, help="удержание тревоги после ухода признаков, c")
ap.add_argument("--gap-s", type=float, default=1.5, help="нет пакетов дольше -> ОБРЫВ линка, c")
ap.add_argument("--warmup-s", type=float, default=8.0, help="прогрев базы: детектор молчит первые N c")
ap.add_argument("--window-s", type=float, default=60.0, help="ширина живого графика, c")
ap.add_argument("--no-freeze", action="store_true",
                help="НЕ замораживать базу во время тревоги (учебный анти-режим!)")
args = ap.parse_args()

if not args.port and not args.replay:
    ap.error("нужен --port (живой режим) или --replay файл.csv")

# ----------------------------- состояние -----------------------------
t0 = time.monotonic()

ts      = collections.deque()   # время, c (хостовое)
rssi    = collections.deque()   # сырой RSSI
fast_md = collections.deque()   # быстрая медиана
base    = collections.deque()   # медленная база
sigma   = collections.deque()   # std быстрого окна
marks   = []                    # отметки правды (MARK), времена
events  = []                    # [t_start, t_end|None, вид('drop'/'boil')]
gaps    = []                    # [t_start, t_end|None] обрывы линка

fast_buf = collections.deque()  # (t, rssi) быстрого окна
baseline = None                 # EMA
alarm_until = 0.0
alarm_active = False
last_pkt_t = None
gap_open = False
n_pkts = 0

# ----------------------------- лог -----------------------------
log_path = args.log or time.strftime("curtain_%Y%m%d_%H%M%S.csv")
log_f = None
log_w = None
if not args.replay:
    log_f = open(log_path, "w", newline="")
    log_w = csv.writer(log_f)
    log_w.writerow(["host_t", "kind", "seq", "rssi", "snr"])  # kind: DATA|MARK
    print(f"[лог] пишу в {log_path} (потом можно --replay)")

# ----------------------------- источник строк -----------------------------
def line_source_serial():
    import serial  # pyserial
    ser = serial.Serial(args.port, args.baud, timeout=0.05)
    print(f"[порт] {args.port} @ {args.baud}. Жду строки DATA/MARK от RX-платы...")
    buf = b""
    while True:
        chunk = ser.read(256)
        if chunk:
            buf += chunk
            while b"\n" in buf:
                line, buf = buf.split(b"\n", 1)
                yield line.decode(errors="replace").strip()
        else:
            yield None  # нет данных прямо сейчас — отдаём управление анимации

def line_source_replay():
    # Проигрываем лог «как будто вживую» (в 1x времени по host_t)
    with open(args.replay) as f:
        rd = csv.DictReader(f)
        rows = list(rd)
    if not rows:
        sys.exit("[replay] пустой лог")
    t_first = float(rows[0]["host_t"])
    t_start = time.monotonic()
    i = 0
    print(f"[replay] {args.replay}: {len(rows)} строк")
    while i < len(rows):
        now_rel = time.monotonic() - t_start
        if float(rows[i]["host_t"]) - t_first <= now_rel:
            r = rows[i]; i += 1
            if r["kind"] == "MARK":
                yield f"MARK,0"
            else:
                yield f"DATA,0,{r['seq']},{r['rssi']},{r['snr']}"
        else:
            yield None
    print("[replay] лог кончился — окно можно разглядывать, Ctrl+C для выхода")
    while True:
        yield None

source = line_source_replay() if args.replay else line_source_serial()

# ----------------------------- детектор -----------------------------
def feed_data(t, seq, r, snr):
    """Один принятый пакет: обновить окна, базу, решить про тревогу."""
    global baseline, alarm_until, alarm_active, last_pkt_t, gap_open, n_pkts

    n_pkts += 1
    last_pkt_t = t

    # обрыв закончился?
    if gap_open:
        gaps[-1][1] = t
        gap_open = False
        print(f"[{t:8.1f}c] ЛИНК ВОССТАНОВЛЕН")

    # быстрое окно
    fast_buf.append((t, r))
    while fast_buf and t - fast_buf[0][0] > args.fast_win:
        fast_buf.popleft()
    vals = np.array([v for _, v in fast_buf])
    fmd = float(np.median(vals))
    fsd = float(np.std(vals)) if len(vals) >= 3 else 0.0

    # медленная база (EMA). Заморозка во время тревоги — см. докстринг.
    if baseline is None:
        baseline = fmd
    freeze = alarm_active and not args.no_freeze
    if not freeze:
        dt = (t - ts[-1]) if ts else 0.07
        a = min(1.0, dt / args.tau_base)
        baseline = baseline + a * (fmd - baseline)

    # признаки
    warm = t >= args.warmup_s
    drop = (baseline - fmd) >= args.drop_db
    boil = fsd >= args.sigma_db
    if warm and (drop or boil):
        if not alarm_active:
            kind = "drop" if drop else "boil"
            events.append([t, None, kind])
            print(f"[{t:8.1f}c] ТРЕВОГА ({'просадка' if drop else 'кипение'}): "
                  f"база={baseline:.1f} медиана={fmd:.1f} std={fsd:.1f}\a")
        alarm_active = True
        alarm_until = t + args.hold_s
    elif alarm_active and t > alarm_until:
        alarm_active = False
        events[-1][1] = t
        print(f"[{t:8.1f}c] отбой, длительность {t - events[-1][0]:.1f} c")

    ts.append(t); rssi.append(r); fast_md.append(fmd)
    base.append(baseline); sigma.append(fsd)

    # подрезаем живое окно (в replay храним всё)
    if not args.replay:
        while ts and t - ts[0] > args.window_s * 1.2:
            ts.popleft(); rssi.popleft(); fast_md.popleft()
            base.popleft(); sigma.popleft()

def check_gap(now):
    """Тишина в эфире = обрыв линка, НЕ нарушитель. Отдельный диагноз."""
    global gap_open
    if last_pkt_t is not None and not gap_open and now - last_pkt_t > args.gap_s:
        gaps.append([last_pkt_t, None])
        gap_open = True
        print(f"[{now:8.1f}c] ОБРЫВ ЛИНКА: нет пакетов > {args.gap_s} c "
              f"(TX на паузе? питание? антенна?)\a")

# ----------------------------- графика -----------------------------
plt.style.use("dark_background")
fig, (ax1, ax2, ax3) = plt.subplots(
    3, 1, figsize=(12, 8), sharex=True,
    gridspec_kw={"height_ratios": [3, 1.4, 1.4]})
fig.canvas.manager.set_window_title("РАДИОЗАНАВЕС — живой эфир")
fig.suptitle("Радиозанавес: тень человека в первой зоне Френеля",
             fontsize=13, fontweight="bold")

ln_raw,  = ax1.plot([], [], ".", ms=3, color="#4a5a6a", alpha=0.6, label="сырой RSSI")
ln_fast, = ax1.plot([], [], "-", lw=2, color="#2dd4bf", label="быстрая медиана (0.5 c)")
ln_base, = ax1.plot([], [], "--", lw=1.6, color="#f5c542", label="медленная база")
ax1.set_ylabel("RSSI, дБм")
ax1.legend(loc="lower left", fontsize=9, framealpha=0.3)
ax1.grid(alpha=0.2)

ln_dev,  = ax2.plot([], [], "-", lw=1.6, color="#60a5fa")
ax2.axhline(0, color="#666", lw=0.8)
thr_dev = ax2.axhline(-args.drop_db, color="#ef4444", ls=":", lw=1.4)
ax2.set_ylabel("медиана − база, дБ")
ax2.grid(alpha=0.2)

ln_sig,  = ax3.plot([], [], "-", lw=1.6, color="#c084fc")
thr_sig = ax3.axhline(args.sigma_db, color="#ef4444", ls=":", lw=1.4)
ax3.set_ylabel("кипение (std), дБ")
ax3.set_xlabel("время, c")
ax3.grid(alpha=0.2)

status_txt = ax1.text(0.99, 0.95, "", transform=ax1.transAxes,
                      ha="right", va="top", fontsize=12, fontweight="bold")
spans = []   # закраски событий/обрывов (перерисовываем целиком)
mark_lines = []

def update(_frame):
    # вычитываем всё, что накопилось (порт быстрее кадра анимации)
    for _ in range(400):
        line = next(source)
        if line is None:
            break
        now = time.monotonic() - t0
        if line.startswith("DATA,"):
            try:
                _, _ms, seq, r, snr = line.split(",")
                feed_data(now, int(seq), float(r), float(snr))
                if log_w: log_w.writerow([f"{now:.3f}", "DATA", seq, r, snr])
            except ValueError:
                pass
        elif line.startswith("MARK"):
            marks.append(now)
            print(f"[{now:8.1f}c] === ОТМЕТКА ПРАВДЫ (судья) ===")
            if log_w: log_w.writerow([f"{now:.3f}", "MARK", "", "", ""])
        elif line.startswith(("===", "[")):
            print(f"[плата] {line}")
    now = time.monotonic() - t0
    check_gap(now)

    if not ts:
        return []
    x = np.array(ts)
    ln_raw.set_data(x, np.array(rssi))
    ln_fast.set_data(x, np.array(fast_md))
    ln_base.set_data(x, np.array(base))
    ln_dev.set_data(x, np.array(fast_md) - np.array(base))
    ln_sig.set_data(x, np.array(sigma))

    xmax = x[-1]
    xmin = 0 if args.replay else max(0, xmax - args.window_s)
    for ax in (ax1, ax2, ax3):
        ax.set_xlim(xmin, max(xmax, xmin + 5))
    ax1.relim(); ax1.autoscale_view(scalex=False)
    ax2.relim(); ax2.autoscale_view(scalex=False)
    ax3.relim(); ax3.autoscale_view(scalex=False)

    # события/обрывы/метки — перерисовать
    for s in spans: s.remove()
    spans.clear()
    for t_a, t_b, kind in events:
        c = "#ef4444" if kind == "drop" else "#f97316"
        spans.append(ax1.axvspan(t_a, t_b or xmax, color=c, alpha=0.18))
    for t_a, t_b in gaps:
        spans.append(ax1.axvspan(t_a, t_b or xmax, color="#3b82f6", alpha=0.15))
    for ml in mark_lines: ml.remove()
    mark_lines.clear()
    for tm in marks:
        for ax in (ax1, ax2, ax3):
            mark_lines.append(ax.axvline(tm, color="#ffffff", ls="--", lw=1.0, alpha=0.7))

    if gap_open:
        status_txt.set_text("ОБРЫВ ЛИНКА"); status_txt.set_color("#60a5fa")
    elif alarm_active:
        status_txt.set_text("ТРЕВОГА"); status_txt.set_color("#ef4444")
    elif now < args.warmup_s:
        status_txt.set_text("прогрев базы..."); status_txt.set_color("#f5c542")
    else:
        status_txt.set_text("охраняется"); status_txt.set_color("#22c55e")
    return []

ani = FuncAnimation(fig, update, interval=100, cache_frame_data=False)

print("\nПодсказки для урока:")
print(f"  порог просадки {args.drop_db} дБ, порог кипения {args.sigma_db} дБ "
      f"(крутить ключами --drop-db / --sigma-db)")
print("  красная заливка = тревога-просадка, оранжевая = тревога-кипение,")
print("  синяя = обрыв линка (это ДРУГОЙ диагноз!), белый пунктир = отметка правды.")
if args.no_freeze:
    print("  ВНИМАНИЕ: --no-freeze — база ползёт за нарушителем (учебный анти-режим).")

try:
    plt.show()
finally:
    if log_f:
        log_f.close()
        print(f"[лог] сохранён: {log_path}")
    # мини-итог для разбора с детьми
    n_ev = len(events)
    print(f"Итог сессии: пакетов={n_pkts}, тревог={n_ev}, отметок правды={len(marks)}, обрывов={len(gaps)}")
    if marks and n_ev:
        hits = sum(1 for tm in marks
                   if any(a - 1.0 <= tm <= (b or tm) + 1.0 for a, b, _ in events))
        print(f"  попаданий (тревога рядом с отметкой ±1 c): {hits}/{len(marks)}, "
              f"остальные тревоги — кандидаты в ложные. Это и есть ваш ROC-опыт.")

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261

/*
  ============================================================================
  «РАДИОЗАНАВЕС» (RF curtain) — охрана периметра на просвет, СБОРКА CURTAIN-1
  ============================================================================
  Идея: TX и RX стоят напротив друг друга. Человек, пересекающий линию,
  перекрывает первую зону Френеля -> RSSI проседает на 3-10 дБ и начинает
  «кипеть» (растёт разброс из-за изменившейся многолучёвки). Устройство
  ГЛУПОЕ: RX просто льёт замеры CSV-строками в консоль, весь детектор и
  вся красота — в питоне (rf_curtain.py): дети крутят пороги и видят.

  Один скетч, две роли — выбор ОДНИМ #define (ROLE_TX / ROLE_RX).

  Железо: E77-900MBL (STM32WLE5CCU6), RadioLib 7.7.1, Arduino STM32 core.
  Радио-обвязка 1:1 из проверенных проектов: PA6=TXEN/PA7=RXEN, RFO_HP,
  OCP 140 мА. ЗАПРЕТЫ: PB0=VDDTCXO (не GPIO), PA2/PA3=консоль.

  РАДИО-КОНФИГ — ДРУГОЙ, чем в охоте на лис, и вот почему:
    Занавесу нужен быстрый пульс: ~15 замеров/с, иначе идущий человек
    проскочит между пакетами. На SF7 это 30% duty — нелегально. Поэтому
    SF5/BW500: эфирное время пакета ~1-2 мс, 15 Гц = ~2-3% duty (лимит 10%
    в поддиапазоне 869.4-869.65). Цена: чувствительность приёмника хуже
    на ~15 дБ — И ЭТО НАМ НА РУКУ: слабый линк = заметнее тень человека.
    Частота 869.4 МГц — тот же разрешённый поддиапазон, но НЕ 869.525
    (это RX2 LoRaWAN у ChirpStack — не гадим в собственный даунлинк!).

  Пакет 6 Б: [0]=0xC4 [1]=0x21 [2]=link_id [3]=seq [4]=tx_power [5]=crc8

  TX: пакет каждые 66 мс (+джиттер 0-4 мс). Кнопка PA0 = пауза/пуск.
  RX: непрерывный приём по IRQ, на каждый пакет CSV-строка:
        DATA,<millis>,<seq>,<rssi>,<snr>
      раз в секунду служебная:  STAT,<millis>,<целых>,<битых>
      кнопка PA0 = ОТМЕТКА ПРАВДЫ: судья жмёт, когда человек реально
      пересекает луч ->  MARK,<millis>  -> питон рисует метку на графике.
      Это основа честного счёта «пропуски vs ложные тревоги» (ROC-опыт).

  Чекпоинты init (бипы): 1 = живы, 3 = радио. Писк 400/400 = init упал.
  ============================================================================
*/

// ======================= РОЛЬ: раскомментировать ОДНУ =======================
#define ROLE_TX
// #define ROLE_RX

#if defined(ROLE_TX) && defined(ROLE_RX)
#error "Выбери ОДНУ роль!"
#endif
#if !defined(ROLE_TX) && !defined(ROLE_RX)
#error "Роль не выбрана: раскомментируй ROLE_TX или ROLE_RX"
#endif

#include <RadioLib.h>

// ============================ ПИНЫ ============================
#define PIN_BTN     PA0    // конт.27 -> GND, INPUT_PULLUP
#define PIN_BUZZER  PB5    // конт.23

// ============================ РАДИО-ПАРАМЕТРЫ ЗАНАВЕСА ============================
#define CURT_FREQ_MHZ   869.400f  // поддиапазон 10% duty; НЕ 869.525 (RX2 LoRaWAN!)
#define CURT_BW_KHZ     500.0f    // широкая полоса = короткий пакет
#define CURT_SF         5         // минимальный SF SX126x = максимум скорости
#define CURT_CR         5         // 4/5
#define CURT_SYNCWORD   0x23      // свой приватный sync (не как у охоты)
#define CURT_POWER_DBM  2         // слабый линк = контрастная тень человека
#define CURT_PREAMBLE   8

#define LINK_ID         1         // задел: два занавеса крест-накрест = 1 и 2
#define TX_PERIOD_MS    66UL      // ~15 замеров/с
#define TX_JITTER_MS    4

// ============================ ПАКЕТ ============================
#define MAGIC0 0xC4
#define MAGIC1 0x21
#pragma pack(push, 1)
struct CurtPacket_t {
  uint8_t magic0;
  uint8_t magic1;
  uint8_t link_id;
  uint8_t seq;
  int8_t  tx_power_dbm;
  uint8_t crc8;
};
#pragma pack(pop)
static_assert(sizeof(CurtPacket_t) == 6, "packet must be 6 bytes");

uint8_t crc8(const uint8_t* d, size_t len) {
  uint8_t crc = 0;
  while (len--) {
    crc ^= *d++;
    for (uint8_t i = 0; i < 8; i++)
      crc = (crc & 0x80) ? (uint8_t)((crc << 1) ^ 0x07) : (uint8_t)(crc << 1);
  }
  return crc;
}

// ============================ РАДИО (обвязка 1:1) ============================
STM32WLx radio = new STM32WLx_Module();

static const uint32_t rfPins[Module::RFSWITCH_MAX_PINS] =
    {PA6, PA7, RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC};
static const Module::RfSwitchMode_t rfTable[] = {
  {STM32WLx::MODE_IDLE,  {LOW,  LOW }},
  {STM32WLx::MODE_RX,    {LOW,  HIGH}},
  {STM32WLx::MODE_TX_HP, {HIGH, LOW }},
  END_OF_MODE_TABLE,
};

// ============================ BUZZER / КНОПКА / ОСТАНОВ ============================
#define BUZZ_FREQ 2700
void beep(uint16_t ms) { tone(PIN_BUZZER, BUZZ_FREQ); delay(ms); noTone(PIN_BUZZER); }
void beepN(uint8_t n) { for (uint8_t i = 0; i < n; i++) { beep(80); delay(120); } }

volatile bool btnIrq = false;
void btnIsr() { btnIrq = true; }

// 0 = нет, 1 = короткое. У RX дебаунс минимальный: отметка правды должна
// ложиться на график с точностью долей секунды.
uint8_t pollButton() {
  if (!btnIrq && digitalRead(PIN_BTN) == HIGH) return 0;
  btnIrq = false;
  delay(30);
  if (digitalRead(PIN_BTN) == HIGH) return 0;
  while (digitalRead(PIN_BTN) == LOW) delay(5);
  return 1;
}

void halt(int16_t code, const char* where) {
  Serial.print(F("[FATAL] ")); Serial.print(where);
  Serial.print(F(" код=")); Serial.println(code);
  while (true) { beep(400); delay(400); }
}

#ifdef ROLE_RX
volatile bool rxFlag = false;
void onRxDone() { rxFlag = true; }
#endif

// ============================ SETUP ============================
void setup() {
  pinMode(PIN_BUZZER, OUTPUT); digitalWrite(PIN_BUZZER, LOW);
  pinMode(PIN_BTN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(PIN_BTN), btnIsr, FALLING);

  Serial.begin(115200);
  delay(1500);
  Serial.println(F("\n=== RF CURTAIN СБОРКА-1: SF5/BW500, 15 Гц ==="));
#ifdef ROLE_TX
  Serial.println(F("[РОЛЬ] TX-луч (кнопка = пауза/пуск)"));
#else
  Serial.println(F("[РОЛЬ] RX-сенсор (кнопка = ОТМЕТКА ПРАВДЫ, строки CSV)"));
#endif
  beepN(1);                                   // чекпоинт 1: живы

  radio.setRfSwitchTable(rfPins, rfTable);
  int16_t s = radio.begin(CURT_FREQ_MHZ, CURT_BW_KHZ, CURT_SF, CURT_CR,
                          CURT_SYNCWORD, CURT_POWER_DBM, CURT_PREAMBLE);
  if (s != RADIOLIB_ERR_NONE) halt(s, "radio.begin");
  radio.setCurrentLimit(140.0f);

  Serial.print(F("[РАДИО] OK: ")); Serial.print(CURT_FREQ_MHZ, 3);
  Serial.print(F(" МГц SF")); Serial.print(CURT_SF);
  Serial.print(F(" BW500 мощн=")); Serial.print(CURT_POWER_DBM);
  Serial.print(F(" dBm | эфир пакета="));
  Serial.print(radio.getTimeOnAir(sizeof(CurtPacket_t)) / 1000.0f, 2);
  Serial.print(F(" мс, duty при 15 Гц ~"));
  Serial.print(radio.getTimeOnAir(sizeof(CurtPacket_t)) * 15.0f / 10000.0f, 1);
  Serial.println(F(" % (лимит 10%)"));
  beepN(3);                                   // чекпоинт 3: радио живо

#ifdef ROLE_RX
  radio.setPacketReceivedAction(onRxDone);
  s = radio.startReceive();
  if (s != RADIOLIB_ERR_NONE) halt(s, "startReceive");
  Serial.println(F("# формат: DATA,millis,seq,rssi,snr | MARK,millis | STAT,millis,good,bad"));
#endif
}

// ############################################################################
// #                                TX-ЛУЧ                                    #
// ############################################################################
#ifdef ROLE_TX

bool paused = false;
uint8_t seq = 0;
uint32_t nextTxAt = 0;

void loop() {
  if (pollButton()) {
    paused = !paused;
    Serial.println(paused ? F("[TX] ПАУЗА") : F("[TX] ПУСК"));
    beepN(paused ? 2 : 1);
  }
  if (!paused && (int32_t)(millis() - nextTxAt) >= 0) {
    CurtPacket_t p;
    p.magic0 = MAGIC0; p.magic1 = MAGIC1;
    p.link_id = LINK_ID; p.seq = seq;
    p.tx_power_dbm = CURT_POWER_DBM;
    p.crc8 = crc8((uint8_t*)&p, sizeof(p) - 1);
    int16_t s = radio.transmit((uint8_t*)&p, sizeof(p));
    if (s != RADIOLIB_ERR_NONE) {
      Serial.print(F("[TX] ошибка ")); Serial.println(s);
    } else {
      seq++;
      if ((seq & 0x3F) == 0) {                // лог раз в 64 пакета, не чаще
        Serial.print(F("[TX] жив, seq=")); Serial.println(seq);
      }
    }
    nextTxAt = millis() + TX_PERIOD_MS + radio.random(TX_JITTER_MS);
  }
  delay(1);
}
#endif // ROLE_TX

// ############################################################################
// #                               RX-СЕНСОР                                  #
// ############################################################################
#ifdef ROLE_RX

uint32_t cntGood = 0, cntBad = 0;
uint32_t nextStatAt = 0;

void loop() {
  // ОТМЕТКА ПРАВДЫ: судья жмёт кнопку в момент реального пересечения луча.
  if (pollButton()) {
    Serial.print(F("MARK,")); Serial.println(millis());
    beep(30);
  }

  if (rxFlag) {
    rxFlag = false;
    uint8_t buf[sizeof(CurtPacket_t)];
    int16_t s = radio.readData(buf, sizeof(buf));
    float rssi = radio.getRSSI();
    float snr  = radio.getSNR();
    radio.startReceive();

    CurtPacket_t* p = (CurtPacket_t*)buf;
    bool ok = (s == RADIOLIB_ERR_NONE) &&
              p->magic0 == MAGIC0 && p->magic1 == MAGIC1 &&
              p->link_id == LINK_ID &&
              p->crc8 == crc8(buf, sizeof(CurtPacket_t) - 1);
    if (ok) {
      cntGood++;
      // CSV для питона: DATA,millis,seq,rssi,snr
      Serial.print(F("DATA,")); Serial.print(millis());
      Serial.print(',');        Serial.print(p->seq);
      Serial.print(',');        Serial.print(rssi, 1);
      Serial.print(',');        Serial.println(snr, 1);
    } else {
      cntBad++;                 // мусор считаем, но питону не шлём
    }
  }

  if ((int32_t)(millis() - nextStatAt) >= 0) {   // служебная строка раз в 1 c
    nextStatAt = millis() + 1000;
    Serial.print(F("STAT,")); Serial.print(millis());
    Serial.print(',');        Serial.print(cntGood);
    Serial.print(',');        Serial.println(cntBad);
  }
  delay(1);
}
#endif // ROLE_RX