FoxHunter — охота на лис (ARDF) на LoRa

  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

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
FOXHUNT — СИМУЛЯТОР ПЕЛЕНГАЦИИ «горячо-холодно» (уроки 1-2, без железа).

Зачем это до выхода на охоту: на реальной охоте ребёнок ищет спрятанную лису по
громкости зуммера охотника (ближе → выше RSSI → чаще пики). Но ПОЧЕМУ громкость
так себя ведёт и почему «горячо везде» при мощной лисе — видно только на карте
поля RSSI. Этот стенд рисует этаж, прячет лису, ведёт охотника мышкой и озвучивает
ТЕ ЖЕ зоны (RYADOM/GORYACHO/TEPLO/HOLODNO), что зашиты в FoxHunt_Hunter.ino —
включая усреднение RSSI и порог тишины.

Физика — та, что стоит за прошивкой:
  * лог-дистанционная модель RSSI(d) = P_tx − PL(d0) − 10·n·lg(d/d0) (n≈3 в здании);
  * усреднение RSSI по окну RSSI_AVG_N пакетов (в прошивке скользящее среднее)
    гасит скачки ±3-5 дБ и даёт плавную «громкость»;
  * зоны громкости ZONES[] и порог тишины RSSI_SILENCE — 1:1 со скетчем охотника.

Ключевой педагогический вывод виден руками: приглушённая лиса (2 дБм) даёт
контрастные зоны на масштабе этажа, а мощная (14 дБм) «затапливает» весь этаж в
RYADOM — искать нечем. Это ровно то, о чём METODIKA.md: «если горячо везде —
убавьте FOX_TX_PWR_DBM».

Управление: двигайте мышь над картой = ходите с охотником. Ползунки — мощность
лисы, показатель n, окно усреднения. Кнопка — спрятать лису заново (случайно).

Запуск:
    uv run foxhunt_sim.py
Без uv:
    pip install numpy matplotlib && python foxhunt_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
from matplotlib.patches import Rectangle, Circle

# --- Радио-параметры (1:1 с foxhunt_common.h / FoxHunt_Hunter.ino) ---
FREQ_MHZ = 869.0
D0_M = 1.0

# Зоны громкости — КОПИЯ ZONES[] из FoxHunt_Hunter.ino (порог по усреднённому RSSI).
# (rssi_min, period_ms, name, цвет). period_ms=0 → сплошной тон (RYADOM).
ZONES = [
    (-55,    0, "RYADOM",  "#dc2626"),   # очень близко: сплошной тон
    (-70,  250, "GORYACHO", "#f97316"),  # горячо
    (-85,  600, "TEPLO",   "#eab308"),   # тепло
    (-100, 1400, "HOLODNO", "#3b82f6"),  # холодно
]
RSSI_SILENCE = -100      # тише — зона молчания (нет ни одной зоны)

# Сцена: этаж SIZE×SIZE метров.
SIZE_M = 40.0
GRID = 200


def rssi_at(dist_m, tx_dbm, n_exp):
    """
    Лог-дистанционная RSSI(d). PL(d0) на 869 МГц ≈ 32.45+20lg(f)+20lg(d0_km).
    Возвращает RSSI в дБм в точке на расстоянии dist_m от лисы.
    """
    dist_m = np.maximum(dist_m, D0_M)
    pl_d0 = 32.45 + 20 * np.log10(FREQ_MHZ) + 20 * np.log10(D0_M / 1000.0)
    pl = pl_d0 + 10 * n_exp * np.log10(dist_m / D0_M)
    # усиления антенн ~2 дБи с каждой стороны (как в остальных проектах)
    return tx_dbm + 2 + 2 - pl


def zone_for(rssi):
    """Возвращает (индекс зоны, имя, цвет, period_ms) или None (тишина)."""
    if rssi < RSSI_SILENCE:
        return None
    for i, (rmin, per, name, col) in enumerate(ZONES):
        if rssi >= rmin:
            return i, name, col, per
    return None


def main():
    st = {"tx": 2.0, "n": 3.0, "avg": 5, "fox": (28.0, 12.0),
          "rssi_buf": []}
    rng = np.random.default_rng(0)

    fig = plt.figure(figsize=(12, 7))
    fig.suptitle("FoxHunt: пеленгация «горячо-холодно» — веди охотника мышью по этажу",
                 fontsize=13, fontweight="bold")
    ax_map = fig.add_axes([0.06, 0.30, 0.52, 0.60])
    ax_prof = fig.add_axes([0.66, 0.55, 0.30, 0.35])
    ax_buzz = fig.add_axes([0.66, 0.32, 0.30, 0.14])

    xs = np.linspace(0, SIZE_M, GRID)
    ys = np.linspace(0, SIZE_M, GRID)
    gx, gy = np.meshgrid(xs, ys)

    hunter = {"pos": (5.0, 5.0)}

    def field():
        fx, fy = st["fox"]
        d = np.hypot(gx - fx, gy - fy)
        return rssi_at(d, st["tx"], st["n"])

    def draw(_=None):
        rssi_map = field()
        fx, fy = st["fox"]
        hx, hy = hunter["pos"]

        # --- карта поля RSSI, раскрашенная по ЗОНАМ (как слышит зуммер) ---
        ax_map.clear()
        # дискретная раскраска по зонам: строим индекс зоны в каждой точке
        zidx = np.full(rssi_map.shape, -1)
        for i, (rmin, _p, _n, _c) in enumerate(ZONES):
            zidx[(rssi_map >= rmin) & (zidx < 0)] = i
        # рисуем зоны от дальней к ближней
        from matplotlib.colors import ListedColormap, BoundaryNorm
        colors = ["#0b1020"] + [z[3] for z in ZONES]   # -1=молчание тёмный
        cmap = ListedColormap(colors)
        norm = BoundaryNorm([-1.5, -0.5, 0.5, 1.5, 2.5, 3.5], cmap.N)
        ax_map.imshow(zidx, origin="lower", extent=[0, SIZE_M, 0, SIZE_M],
                      cmap=cmap, norm=norm, aspect="equal", alpha=0.85)
        # лиса скрыта от «игрока», но для учителя покажем полупрозрачно
        ax_map.add_patch(Circle((fx, fy), 0.6, color="white", ec="black", lw=1.2))
        ax_map.text(fx, fy + 1.2, "лиса", color="white", ha="center", fontsize=8,
                    fontweight="bold")
        # охотник
        ax_map.add_patch(Circle((hx, hy), 0.7, color="#22d3ee", ec="black", lw=1.5))
        ax_map.set_xlim(0, SIZE_M)
        ax_map.set_ylim(0, SIZE_M)
        ax_map.set_xlabel("метры")
        ax_map.set_ylabel("метры")
        ax_map.set_title("Карта зон громкости (что слышит зуммер). "
                         "Двигай мышь = иди с охотником", fontsize=9)

        # --- профиль RSSI(расстояние) с порогами зон ---
        ax_prof.clear()
        dline = np.linspace(D0_M, SIZE_M, 200)
        ax_prof.plot(dline, rssi_at(dline, st["tx"], st["n"]),
                     color="#334155", lw=2)
        for rmin, _p, name, col in ZONES:
            ax_prof.axhline(rmin, color=col, ls=":", lw=1.2)
            ax_prof.text(SIZE_M, rmin + 0.5, name, color=col, ha="right", fontsize=7)
        ax_prof.axhline(RSSI_SILENCE, color="#64748b", ls="--", lw=1)
        # текущее расстояние охотника
        dh = np.hypot(hx - fx, hy - fy)
        ax_prof.axvline(dh, color="#22d3ee", lw=1.5)
        ax_prof.set_xlabel("расстояние до лисы, м")
        ax_prof.set_ylabel("RSSI, дБм")
        ax_prof.set_ylim(-115, -30)
        ax_prof.set_title("RSSI(расстояние) и пороги зон", fontsize=9)
        ax_prof.grid(alpha=0.25)

        # --- «зуммер»: текущая зона с усреднением, как в прошивке ---
        ax_buzz.clear()
        ax_buzz.axis("off")
        raw = rssi_at(dh, st["tx"], st["n"]) + rng.normal(0, 2.0)  # скачок ±дБ
        buf = st["rssi_buf"]
        buf.append(raw)
        while len(buf) > int(st["avg"]):
            buf.pop(0)
        avg = float(np.mean(buf))
        z = zone_for(avg)
        if z is None:
            name, col, per = "ТИШИНА", "#334155", None
        else:
            _i, name, col, per = z
        beep = "сплошной тон" if per == 0 else (f"пик каждые {per} мс" if per else "—")
        ax_buzz.add_patch(Rectangle((0, 0), 1, 1, transform=ax_buzz.transAxes,
                                    color=col, alpha=0.85))
        ax_buzz.text(0.5, 0.62, name, transform=ax_buzz.transAxes, ha="center",
                     va="center", fontsize=16, fontweight="bold", color="white")
        ax_buzz.text(0.5, 0.25,
                     f"RSSI(avg {int(st['avg'])})={avg:.0f} дБм   {beep}",
                     transform=ax_buzz.transAxes, ha="center", va="center",
                     fontsize=9, color="white")

        fig.canvas.draw_idle()

    def on_move(event):
        if event.inaxes is ax_map and event.xdata is not None:
            hunter["pos"] = (event.xdata, event.ydata)
            draw()

    fig.canvas.mpl_connect("motion_notify_event", on_move)

    ax_tx = fig.add_axes([0.12, 0.18, 0.40, 0.03])
    s_tx = Slider(ax_tx, "Мощность лисы, дБм", 0, 14, valinit=st["tx"], valstep=1)
    ax_n = fig.add_axes([0.12, 0.12, 0.40, 0.03])
    s_n = Slider(ax_n, "Показатель n (здание ~3)", 2.0, 4.0, valinit=st["n"], valstep=0.1)
    ax_av = fig.add_axes([0.12, 0.06, 0.40, 0.03])
    s_av = Slider(ax_av, "Окно усреднения RSSI_AVG_N", 1, 9, valinit=st["avg"], valstep=1)

    def on_tx(v): st["tx"] = v; draw()
    def on_n(v): st["n"] = v; draw()
    def on_av(v): st["avg"] = v; st["rssi_buf"].clear(); draw()
    s_tx.on_changed(on_tx)
    s_n.on_changed(on_n)
    s_av.on_changed(on_av)

    ax_hide = fig.add_axes([0.66, 0.13, 0.30, 0.05])
    b_hide = Button(ax_hide, "Спрятать лису заново")

    def hide(_):
        st["fox"] = (float(rng.uniform(4, SIZE_M - 4)),
                     float(rng.uniform(4, SIZE_M - 4)))
        st["rssi_buf"].clear()
        draw()
    b_hide.on_clicked(hide)

    draw()
    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

/*
  ============================================================================
  FOXHUNT — ОБЩИЙ ЗАГОЛОВОК (единый источник правды для всех ролей)
  ============================================================================
  Сюда вынесено ВСЁ, что обязано СОВПАДАТЬ у Лисы, Охотника и Фальшлисы:
  радио-параметры, структура пакета, таблица ВЧ-ключа E77, учебная подпись.

  ПОЧЕМУ ОТДЕЛЬНЫЙ ФАЙЛ: раньше эти вещи были скопированы в каждый .ino.
  Стоило поправить одно поле в структуре в одном файле и забыть в другом —
  и роли переставали понимать друг друга. Теперь правка в одном месте.

  КАК ПОДКЛЮЧИТЬ: положите этот файл рядом с .ino (в той же папке скетча)
  и напишите вверху скетча:  #include "foxhunt_common.h"

  ЖЕЛЕЗО: CDEBYTE E77-900MBL-01 (STM32WLE5CCU6). ВЧ-ключ PA6=TXEN, PA7=RXEN.
  ============================================================================
*/
#ifndef FOXHUNT_COMMON_H
#define FOXHUNT_COMMON_H

#include <RadioLib.h>

// ============================================================================
// РАДИО-ПАРАМЕТРЫ — ДОЛЖНЫ БЫТЬ ОДИНАКОВЫ У ВСЕХ РОЛЕЙ
// ============================================================================
// Частота: 868.7–869.2 МГц в РФ исторически разрешает 25 мВт со свободной
// скважностью (проверьте АКТУАЛЬНУЮ редакцию решения ГКРЧ — нормы меняются).
// Для пеленгации важна свободная скважность: лиса вещает часто.
#define LORA_FREQ_MHZ       869.0f
#define LORA_BW_KHZ         125.0f

// SF7 (а не SF10!) — ОСОЗНАННЫЙ выбор для пеленгации:
//   airtime пакета ~30 мс вместо ~330 мс → можно слать маяк часто,
//   а частый маяк = плавная стрелка "громкости" при движении/вращении.
//   Потеря чувствительности ~7-8 дБ против SF10 роли не играет: в здании и
//   парке дистанции малы. Для дальней уличной охоты см. коммент в лисе.
#define LORA_SF             7
#define LORA_CR             5        // 4/5
#define LORA_SYNC_WORD      0x12     // приватная сеть (не 0x34 = LoRaWAN public)
#define LORA_PREAMBLE       8

// Мощность. 14 дБм = 25 мВт. НЕ превышать разрешённое! Для ближней охоты
// в здании можно СНИЗИТЬ (см. FOX_TX_PWR_DBM в лисе) — так RSSI не насыщается.
#define LORA_TX_PWR_DBM     14

// ============================================================================
// СТРУКТУРА ПАКЕТА-МАЯКА (компактный бинарный формат, 9 байт)
//   Offset Size Field
//   0      1    fox_id      — какая лиса (1..5, как MOE/MOI/... в ARDF)
//   1      4    fcnt        — счётчик кадров (для урока про replay-защиту)
//   5      2    bat_mv      — напряжение питания, мВ (телеметрия)
//   7      1    tx_pwr_dbm  — мощность TX, дБм (signed! для расчёта FSPL)
//   8      1    signature   — учебная 1-байтовая подпись (см. ниже)
// ============================================================================
#pragma pack(push, 1)
struct FoxBeacon_t {
  uint8_t  fox_id;
  uint32_t fcnt;
  uint16_t bat_mv;
  int8_t   tx_pwr_dbm;
  uint8_t  signature;
};
#pragma pack(pop)

// ============================================================================
// УЧЕБНАЯ ПОДПИСЬ
//   ЧЕСТНОЕ ПРЕДУПРЕЖДЕНИЕ ДЛЯ УРОКА: эта подпись СЛАБАЯ НАМЕРЕННО.
//   XOR всех ключевых байтов схлопывается в одну константу, поэтому подпись
//   фактически = XOR(данные) ^ K, где K — одна константа. Её можно подобрать
//   перебором 256 значений НЕ ЗНАЯ ключа. Это НЕ баг — это учебный материал:
//   на этом показываем, ЗАЧЕМ настоящие системы берут AES-CMAC (см. LoRaWAN-
//   ветку проекта). Не использовать нигде, кроме класса.
// ============================================================================
#define HMAC_KEY_LEN  8
static const uint8_t HMAC_KEY[HMAC_KEY_LEN] = {
  0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0x13, 0x37
};

// Подпись по всем полям, КРОМЕ самого байта signature (последний).
static inline uint8_t foxCalcSignature(const FoxBeacon_t &pkt) {
  const uint8_t *raw = (const uint8_t*)&pkt;
  uint8_t sig = 0;
  for (uint8_t i = 0; i < sizeof(FoxBeacon_t) - 1; i++) {
    sig ^= raw[i] ^ HMAC_KEY[i % HMAC_KEY_LEN];
  }
  return sig;
}

// ============================================================================
// ТАБЛИЦА ВЧ-КЛЮЧА E77 — ГРАБЛИ ЖЕЛЕЗА, задокументированы и обойдены
//   E77-900M22S разведён ТОЛЬКО на RFO_HP. MODE_TX_LP убран НАМЕРЕННО:
//   иначе при power<=15 дБм RadioLib ушёл бы на неподключённый RFO_LP и
//   в эфир пошла бы только утечка (RSSI у приёмника падает на ~80 дБ).
//   _rfPins ОБЯЗАН содержать ровно RFSWITCH_MAX_PINS (5) элементов — иначе
//   ссылка const uint32_t(&)[5] в setRfSwitchTable не биндится (ошибка сборки).
//
//   ИСПОЛЬЗОВАНИЕ (в begin() каждой роли, ДО radio.begin()):
//     radio.setRfSwitchTable(FOX_RF_PINS, FOX_RF_TABLE);
//   Массивы объявлены static, чтобы жили в каждой единице трансляции.
// ============================================================================
static const uint32_t FOX_RF_PINS[Module::RFSWITCH_MAX_PINS] =
    { PA6, PA7, RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC };

static const Module::RfSwitchMode_t FOX_RF_TABLE[] = {
  { STM32WLx::MODE_IDLE,  {LOW,  LOW } },  // оба LOW: ключ закрыт, ток не течёт
  { STM32WLx::MODE_RX,    {LOW,  HIGH} },
  { STM32WLx::MODE_TX_HP, {HIGH, LOW } },  // единственный TX-режим этого модуля
  END_OF_MODE_TABLE,
};

// OCP: HP PA не душить по току.
#define FOX_OCP_MA  140.0f

#endif // FOXHUNT_COMMON_H

  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

/*
  ============================================================================
  FOXHUNT — «ЛИСА» (передатчик), редакция для ПЕЛЕНГАЦИИ
  ============================================================================
  Отличия от прежней версии — всё ради того, чтобы лису РЕАЛЬНО НАХОДИЛИ:

   1. БЫСТРЫЙ МАЯК. Раньше: 3 пакета, потом 10 с тишины → охотник получал
      свежий RSSI раз в 2 с, а в паузе слеп 10 с. Пеленговать невозможно.
      Теперь: в свою "минуту эфира" лиса шлёт маяк КАЖДЫЕ BEACON_MS (по умолч.
      300 мс). Крутишь антенну / бежишь — громкость обновляется плавно.

   2. РАСПИСАНИЕ ПО ОЧЕРЕДИ (как в настоящем ARDF). Лисы делят цикл на слоты:
      лиса 1 вещает свой слот, молчит; лиса 2 — свой, и т.д. Задаётся FOX_ID
      и FOX_COUNT. Одна лиса = непрерывный маяк (для самого первого запуска).

   3. МОЩНОСТЬ ПОД ДИСТАНЦИЮ. В здании 14 дБм насыщают RSSI уже в соседней
      комнате ("горячо" везде). FOX_TX_PWR_DBM позволяет приглушить лису до
      0..6 дБм — тогда "горячо-холодно" различимо на масштабе этажа.

  ЖЕЛЕЗО: CDEBYTE E77-900MBL-01. Общие параметры — в foxhunt_common.h.
  ============================================================================
*/
#include "foxhunt_common.h"

// ============================================================================
// НАСТРОЙКИ ЭТОЙ ЛИСЫ (единственное, что меняется от лисы к лисе)
// ============================================================================
#define FOX_ID            1        // номер ЭТОЙ лисы: 1..FOX_COUNT
#define FOX_COUNT         1        // сколько лис всего. 1 = непрерывный маяк.
                                   // Поставьте 3 и прошейте три модуля с
                                   // FOX_ID 1,2,3 — пойдут по очереди.

#define BEACON_MS         300UL    // период маяка в АКТИВНОМ слоте (мс)
#define SLOT_MS           60000UL  // длительность одного слота (мс). 60 с —
                                   // классическая "минута" ARDF. Для тренировки
                                   // в здании удобно уменьшить до 20000.

// Мощность именно ЭТОЙ лисы. Перекрывает LORA_TX_PWR_DBM из common для
// ближней охоты. В здании начните с 2 дБм и поднимайте, если сигнал теряется.
#define FOX_TX_PWR_DBM    2        // 2 дБм для здания; 14 для улицы/парка

// ЗАМЕТКА ПРО ДАЛЬНЮЮ УЛИЧНУЮ ОХОТУ: если гоняете в большом парке и сигнал
// на SF7 не добивает — верните SF10 в common (дальше, но маяк придётся
// сделать реже, ~1000 мс, из-за airtime). Для здания/двора SF7 идеален.

// ============================================================================
// РАДИО (глобально — против static init-order fiasco)
// ============================================================================
STM32WLx radio = new STM32WLx_Module();

uint32_t g_fcnt   = 0;
uint32_t g_slotT0 = 0;   // начало текущего цикла расписания

void halt(int16_t s, const char* tag) {
  if (s != RADIOLIB_ERR_NONE) {
    Serial.print(F("[HALT] ")); Serial.print(tag);
    Serial.print(F(" err=")); Serial.println(s);
    for (;;) delay(1000);
  }
}

// Vdd через внутренний VREFINT (analogReadVcc в STM32duino НЕТ).
uint16_t readBatteryMv() {
  analogReadResolution(12);
  uint32_t vrefRaw = analogRead(AVREF);
  return (uint16_t)__LL_ADC_CALC_VREFANALOG_VOLTAGE(vrefRaw, LL_ADC_RESOLUTION_12B);
}

// Активен ли слот ЭТОЙ лисы прямо сейчас?
// FOX_COUNT==1 → всегда активна (непрерывный маяк).
bool isMySlot() {
  if (FOX_COUNT <= 1) return true;
  uint32_t elapsed = millis() - g_slotT0;
  uint32_t cycle   = (uint32_t)FOX_COUNT * SLOT_MS;
  if (elapsed >= cycle) {                 // цикл закончился — начать новый
    g_slotT0 += cycle;
    elapsed  = millis() - g_slotT0;
  }
  uint8_t activeSlot = elapsed / SLOT_MS;  // 0..FOX_COUNT-1
  return (activeSlot == (FOX_ID - 1));
}

void transmitBeacon() {
  g_fcnt++;
  FoxBeacon_t pkt;
  pkt.fox_id     = FOX_ID;
  pkt.fcnt       = g_fcnt;
  pkt.bat_mv     = readBatteryMv();
  pkt.tx_pwr_dbm = FOX_TX_PWR_DBM;
  pkt.signature  = foxCalcSignature(pkt);

  int16_t s = radio.transmit((uint8_t*)&pkt, sizeof(pkt));
  if (s == RADIOLIB_ERR_NONE) {
    Serial.print(F("[TX] fox=")); Serial.print(FOX_ID);
    Serial.print(F(" fcnt=")); Serial.print(g_fcnt);
    Serial.print(F(" bat=")); Serial.print(pkt.bat_mv);
    Serial.println(F("mV"));
  } else {
    Serial.print(F("[TX] ERR=")); Serial.println(s);
  }
}

void setup() {
  Serial.begin(115200);
  delay(1500);
  Serial.println(F("\n=== FOXHUNT — ЛИСА (пеленгация) ==="));

  radio.setRfSwitchTable(FOX_RF_PINS, FOX_RF_TABLE);   // ДО begin()!
  int16_t s = radio.begin(LORA_FREQ_MHZ, LORA_BW_KHZ, LORA_SF, LORA_CR,
                          LORA_SYNC_WORD, FOX_TX_PWR_DBM, LORA_PREAMBLE);
  halt(s, "radio.begin");
  radio.setCurrentLimit(FOX_OCP_MA);

  g_slotT0 = millis();
  Serial.print(F("[FOX] ID=")); Serial.print(FOX_ID);
  Serial.print(F("/")); Serial.print(FOX_COUNT);
  Serial.print(F("  freq=")); Serial.print(LORA_FREQ_MHZ);
  Serial.print(F("MHz  SF")); Serial.print(LORA_SF);
  Serial.print(F("  pwr=")); Serial.print(FOX_TX_PWR_DBM);
  Serial.println(F("dBm"));
  if (FOX_COUNT <= 1) Serial.println(F("[FOX] Режим: непрерывный маяк"));
  else Serial.println(F("[FOX] Режим: расписание по очереди (ARDF)"));
}

void loop() {
  if (isMySlot()) {
    transmitBeacon();
    delay(BEACON_MS);
  } else {
    delay(50);   // чужой слот — молчим, но часто проверяем расписание
  }
}

  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
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431

/*
  ============================================================================
  FOXHUNT — «ОХОТНИК» (приёмник), редакция для ПЕЛЕНГАЦИИ
  ============================================================================
  Это СЕРДЦЕ опыта: именно здесь рождается ощущение "горячо-холодно".
  Что изменено против прежней версии и ЗАЧЕМ:

   1. УСРЕДНЕНИЕ RSSI (скользящее среднее). Сырой RSSI LoRa скачет на ±3-5 дБ
      от пакета к пакету. Без усреднения зуммер дёргается и врёт про "ближе".
      Окно из RSSI_AVG_N пакетов даёт плавную, честную "громкость".

   2. ТАЙМАУТ ПОТЕРИ СИГНАЛА. Раньше: если лиса замолчала (чужой слот, ушли из
      зоны, села батарея) — зуммер ВЕЧНО пищал в последней зоне. Теперь: нет
      валидного пакета SIGNAL_TIMEOUT_MS → RSSI сбрасывается → тишина. Это и
      честно, и решает "пищит, а лисы рядом нет".

   3. ID ЛИСЫ СЛЫШЕН. Перед серией бипов охотник "проговаривает" номер лисы
      короткими сигналами (лиса 1 = "пик", лиса 2 = "пик-пик"). Так на слух,
      не глядя на экран, ребёнок понимает, КОГО он сейчас пеленгует —
      цифровой аналог позывных MOE/MOI/MOS настоящего ARDF.

   4. HEX-ДАМП ПРИНЯТОГО ПАКЕТА в Serial. Нужен для урока про безопасность:
      дети копируют реальные байты и вставляют в фальшлису для replay-атаки.

  OLED опционален: нет дисплея — охота не срывается, всё слышно зуммером.

  ЖЕЛЕЗО: E77 + пассивный зуммер на BUZZER_PIN (+OLED 128x64 SSD1306 опц.).
  ============================================================================
*/
#include "foxhunt_common.h"
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// ============================================================================
// ПЕРИФЕРИЯ
// ============================================================================
#define BUZZER_PIN          PA0
#define BUZZER_FREQ_HZ      2700     // резонанс большинства пьезо

#define OLED_WIDTH   128
#define OLED_HEIGHT   64
#define OLED_RESET    -1
#define OLED_ADDR   0x3C
#define I2C_SDA_PIN  PB7
#define I2C_SCL_PIN  PB6

// ============================================================================
// НАСТРОЙКИ ПЕЛЕНГАЦИИ
// ============================================================================
#define RSSI_AVG_N          5        // окно усреднения RSSI (пакетов).
                                     // Быстро бегают → уменьшите до 3 (отзывчивее).
                                     // Сигнал скачет → увеличьте до 7 (плавнее).
#define SIGNAL_TIMEOUT_MS   2500UL   // нет пакета дольше → считаем сигнал потерян
#define OLED_REDRAW_MS      200UL    // как часто перерисовывать OLED (не на каждый пакет!)
#define NOISE_PRINT_MS      2000UL   // как часто печатать уровень шума эфира (мс)

// Зоны "громкости". Порог — по УСРЕДНЁННОМУ RSSI. period=0 → сплошной тон.
// Пороги подобраны под приглушённую лису (2 дБм) в здании. Для 14 дБм/улицы
// сдвиньте все пороги вниз на ~20 дБ (или сделайте лису тише — это проще).
struct Zone { int16_t rssi_min; uint16_t period_ms; uint16_t beep_ms; const char* name; };
static const Zone ZONES[] = {
  { -55,    0,   0, "RYADOM" },   // очень близко: сплошной тон
  { -70,  250, 120, "GORYACHO"},  // горячо
  { -85,  600, 100, "TEPLO"   },  // тепло
  {-100, 1400,  70, "HOLODNO" },  // холодно
};
static const uint8_t ZONE_N = sizeof(ZONES)/sizeof(ZONES[0]);
#define RSSI_SILENCE  -100           // тише этого — зона молчания (нет ни одной)

// ============================================================================
// РАДИО + ISR-ФЛАГ
// ============================================================================
STM32WLx radio = new STM32WLx_Module();
volatile bool g_rxFlag = false;
void onPacketReceived() { g_rxFlag = true; }   // только флаг, ничего больше!

// ============================================================================
// СОСТОЯНИЕ ОХОТНИКА
// ============================================================================
float    g_rssiBuf[RSSI_AVG_N];
uint8_t  g_rssiIdx   = 0;
uint8_t  g_rssiCount = 0;             // сколько реальных отсчётов накоплено
uint32_t g_lastRxMs  = 0;
uint8_t  g_curFox    = 0;             // какую лису слышим сейчас (для "проговора")
uint32_t g_received  = 0;
uint32_t g_lastFcnt[6] = {0};         // счётчик по каждому fox_id (1..5), [0] не исп.

// Распознавание РЕБУТА лисы (а не атаки). Ребут: подпись верна, fcnt низкий,
// но СТАБИЛЬНО РАСТЁТ. Replay-атака: подпись верна, fcnt низкий и НЕ растёт
// (переигрывается один зафиксированный пакет). По этому и различаем.
uint32_t g_resyncSeen[6] = {0};       // последний "подозрительный" fcnt по лисе
uint8_t  g_resyncRun[6]  = {0};       // сколько подряд растущих подозрительных
#define  RESYNC_N  3                  // столько растущих подряд → это ребут, ресинк
uint32_t g_lastNoiseMs = 0;           // когда последний раз печатали шум

// Состояние для отрисовки OLED по таймеру (а не на каждый пакет — иначе радио
// глохнет на отрисовке). processBeacon только ЗАПОМИНАЕТ, что показать;
// сама отрисовка — в loop() не чаще OLED_REDRAW_MS.
bool     g_oledDirty  = false;        // есть что перерисовать
uint8_t  g_dispFox    = 0;
float    g_dispRssi   = -130.0f;
float    g_dispSnr    = 0.0f;
bool     g_dispSecure = true;
uint32_t g_lastOledMs = 0;

Adafruit_SSD1306 oled(OLED_WIDTH, OLED_HEIGHT, &Wire, OLED_RESET);
bool g_hasOled = false;

// ---- усреднение RSSI ----
void rssiPush(float v) {
  g_rssiBuf[g_rssiIdx] = v;
  g_rssiIdx = (g_rssiIdx + 1) % RSSI_AVG_N;
  if (g_rssiCount < RSSI_AVG_N) g_rssiCount++;
}
float rssiAvg() {
  if (g_rssiCount == 0) return -130.0f;
  float s = 0; for (uint8_t i=0;i<g_rssiCount;i++) s += g_rssiBuf[i];
  return s / g_rssiCount;
}
void rssiReset() { g_rssiCount = 0; g_rssiIdx = 0; }

const Zone* findZone(float rssi) {
  for (uint8_t i=0;i<ZONE_N;i++) if (rssi >= ZONES[i].rssi_min) return &ZONES[i];
  return nullptr;
}

// ============================================================================
// ЗУММЕР (неблокирующий FSM) + "проговор" ID лисы
// ============================================================================
bool     g_beeping   = false;
bool     g_solid     = false;
uint32_t g_beepT0    = 0;

// Проговор номера лисы: короткие пики перед серией. Неблокирующий.
uint8_t  g_announceLeft = 0;    // сколько пиков осталось проговорить
bool     g_announceOn   = false;
uint32_t g_announceT0   = 0;
#define ANNOUNCE_BEEP_MS  80
#define ANNOUNCE_GAP_MS   120

void startAnnounce(uint8_t foxId) {
  g_announceLeft = foxId;       // лиса N = N пиков
  g_announceOn   = false;
  g_announceT0   = millis();
  noTone(BUZZER_PIN);
  g_beeping = g_solid = false;
}

// true, пока идёт проговор (тогда обычный зуммер молчит)
bool announceUpdate() {
  if (g_announceLeft == 0 && !g_announceOn) return false;
  uint32_t now = millis();
  if (g_announceOn) {
    if (now - g_announceT0 >= ANNOUNCE_BEEP_MS) {
      noTone(BUZZER_PIN); g_announceOn = false; g_announceT0 = now;
      g_announceLeft--;
    }
  } else {
    if (g_announceLeft == 0) return false;
    if (now - g_announceT0 >= ANNOUNCE_GAP_MS) {
      tone(BUZZER_PIN, BUZZER_FREQ_HZ + 600);  // проговор чуть выше по тону
      g_announceOn = true; g_announceT0 = now;
    }
  }
  return true;
}

void buzzerUpdate(float rssi) {
  if (announceUpdate()) return;    // пока проговариваем ID — обычный зуммер ждёт

  if (rssi < RSSI_SILENCE) {
    if (g_beeping || g_solid) { noTone(BUZZER_PIN); g_beeping=g_solid=false; }
    return;
  }
  const Zone* z = findZone(rssi);
  if (!z) { if(g_beeping||g_solid){noTone(BUZZER_PIN);g_beeping=g_solid=false;} return; }

  if (z->period_ms == 0) {         // сплошной тон
    if (!g_solid) { tone(BUZZER_PIN, BUZZER_FREQ_HZ); g_solid=true; g_beeping=false; }
    return;
  }
  if (g_solid) { noTone(BUZZER_PIN); g_solid=false; }

  uint32_t now = millis();
  if (g_beeping) {
    if (now - g_beepT0 >= z->beep_ms) { noTone(BUZZER_PIN); g_beeping=false; g_beepT0=now; }
  } else {
    uint32_t pause = z->period_ms - z->beep_ms;
    if (now - g_beepT0 >= pause) { tone(BUZZER_PIN, BUZZER_FREQ_HZ); g_beeping=true; g_beepT0=now; }
  }
}

// ============================================================================
// OLED
// ============================================================================
void oledWaiting() {
  if (!g_hasOled) return;
  oled.clearDisplay(); oled.setTextSize(1); oled.setTextColor(SSD1306_WHITE);
  oled.setCursor(0,0);  oled.print(F("FOXHUNT — HUNTER"));
  oled.drawFastHLine(0,10,OLED_WIDTH,SSD1306_WHITE);
  oled.setCursor(0,16); oled.print(F("Slushayu efir..."));
  oled.setCursor(0,28); oled.print(LORA_FREQ_MHZ); oled.print(F(" MHz SF"));
  oled.print(LORA_SF);
  oled.setCursor(0,44); oled.print(F("Pkts OK: ")); oled.print(g_received);
  oled.display();
}

void oledBeacon(uint8_t foxId, float rssiAvgVal, float snr, bool secure) {
  if (!g_hasOled) return;
  oled.clearDisplay(); oled.setTextColor(SSD1306_WHITE);
  oled.setTextSize(1); oled.setCursor(0,0);
  oled.print(F("FOX ")); oled.print(foxId);
  oled.setCursor(secure?84:78,0); oled.print(secure?F("[OK]"):F("[FAKE]"));
  oled.drawFastHLine(0,10,OLED_WIDTH,SSD1306_WHITE);

  oled.setTextSize(2); oled.setCursor(0,14);
  oled.print(F("RSSI")); oled.setCursor(0,32); oled.print((int16_t)rssiAvgVal);
  oled.print(F(" dB"));

  // прогресс-бар громкости
  const float LO=-110.0f, HI=-45.0f;
  float c = rssiAvgVal; if(c<LO)c=LO; if(c>HI)c=HI;
  uint8_t w=(uint8_t)((c-LO)/(HI-LO)*(OLED_WIDTH-2));
  oled.drawRect(0,52,OLED_WIDTH,10,SSD1306_WHITE);
  oled.fillRect(1,53,w,8,SSD1306_WHITE);
  oled.display();
}

// Лёгкая замена прямого вызова oledBeacon: только ЗАПОМИНАЕТ, что показать.
// Реальная (медленная) отрисовка — в loop() по таймеру OLED_REDRAW_MS.
void oledBeaconLater(uint8_t foxId, float rssiAvgVal, float snr, bool secure) {
  g_dispFox = foxId; g_dispRssi = rssiAvgVal; g_dispSnr = snr;
  g_dispSecure = secure; g_oledDirty = true;
}

// ============================================================================
// ОБРАБОТКА ПАКЕТА
// ============================================================================
void hexDump(const uint8_t* b, uint8_t n) {
  Serial.print(F("[RAW] "));
  for (uint8_t i=0;i<n;i++){ if(b[i]<16)Serial.print('0'); Serial.print(b[i],HEX); Serial.print(' '); }
  Serial.println();
}

void processBeacon(const FoxBeacon_t* pkt, float rssi, float snr, const uint8_t* raw, uint8_t rawLen) {
  bool sigOk = (foxCalcSignature(*pkt) == pkt->signature);
  uint8_t fid = pkt->fox_id;
  if (fid < 1 || fid > 5) fid = 5;   // защита индекса g_lastFcnt

  // Дубль того же кадра (повторный IRQ) — не атака, тихо игнор.
  if (sigOk && pkt->fcnt == g_lastFcnt[fid]) {
    Serial.print(F("[DUP] fox=")); Serial.print(fid);
    Serial.print(F(" fcnt=")); Serial.println(pkt->fcnt);
    return;
  }
  bool fcntOk = (pkt->fcnt > g_lastFcnt[fid]);
  bool secure = sigOk && fcntOk;

  hexDump(raw, rawLen);   // всегда печатаем сырьё — для урока перехвата

  if (!secure) {
    // Подпись верна, но fcnt не выше запомненного. Два разных случая:
    //   (а) РЕБУТ ЛИСЫ: её счётчик обнулился и снова растёт. fcnt низкий, но
    //       увеличивается от пакета к пакету. Это НЕ атака — надо ресинкнуться.
    //   (б) REPLAY-АТАКА: переигрывается ОДИН старый пакет, fcnt стоит на месте.
    // Различаем по динамике: растёт RESYNC_N раз подряд → ребут → ресинк.
    if (sigOk) {
      if (pkt->fcnt > g_resyncSeen[fid]) {
        g_resyncRun[fid]++;                 // подозрительный, но растущий
      } else {
        g_resyncRun[fid] = 1;               // не растёт (или откат) — счёт заново
      }
      g_resyncSeen[fid] = pkt->fcnt;

      if (g_resyncRun[fid] >= RESYNC_N) {
        // Уверенно: лиса перезагрузилась. Принимаем новый отсчёт как истину.
        Serial.print(F("[RESYNC] fox=")); Serial.print(fid);
        Serial.print(F(" лиса перезагрузилась, синхронизирую с fcnt="));
        Serial.println(pkt->fcnt);
        g_lastFcnt[fid] = pkt->fcnt;
        g_resyncRun[fid] = 0;
        secure = true;                      // проваливаемся в обычную обработку ниже
      }
    }

    if (!secure) {
      Serial.print(F("[SEC] REJECT fox=")); Serial.print(fid);
      Serial.print(F(" fcnt=")); Serial.print(pkt->fcnt);
      Serial.print(sigOk?F(" SIG:OK"):F(" SIG:FAIL"));
      Serial.print(fcntOk?F(" FCNT:OK"):F(" FCNT:REPLAY"));
      if (sigOk) { Serial.print(F(" (resync ")); Serial.print(g_resyncRun[fid]);
                   Serial.print(F("/")); Serial.print(RESYNC_N); Serial.print(F(")")); }
      Serial.println();
      oledBeaconLater(fid, rssi, snr, false);   // [FAKE] — отрисуется по таймеру
      return;
    }
  }

  // Успешный приём (или ресинк) → сбрасываем подозрение по этой лисе.
  g_resyncRun[fid] = 0;
  g_resyncSeen[fid] = 0;

  g_lastFcnt[fid] = pkt->fcnt;
  g_received++;

  // Сменилась лиса → сброс усреднения и проговор нового ID
  if (fid != g_curFox) {
    g_curFox = fid;
    rssiReset();
    startAnnounce(fid);
  }
  rssiPush(rssi);
  g_lastRxMs = millis();

  float avg = rssiAvg();
  const Zone* z = findZone(avg);
  Serial.print(F("[RX] fox=")); Serial.print(fid);
  Serial.print(F(" fcnt=")); Serial.print(pkt->fcnt);
  Serial.print(F(" rssi=")); Serial.print(rssi,1);
  Serial.print(F(" avg=")); Serial.print(avg,1);
  Serial.print(F(" snr=")); Serial.print(snr,1);
  Serial.print(F(" bat=")); Serial.print(pkt->bat_mv);
  Serial.print(F("mV zone=")); Serial.println(z?z->name:"SILENCE");

  oledBeaconLater(fid, avg, snr, true);   // отрисуется по таймеру в loop()
}

// ============================================================================
// SETUP / LOOP
// ============================================================================
void setup() {
  Serial.begin(115200);
  delay(1500);
  Serial.println(F("\n=== FOXHUNT — ОХОТНИК (пеленгация) ==="));

  radio.setRfSwitchTable(FOX_RF_PINS, FOX_RF_TABLE);   // ДО begin()!
  int16_t s = radio.begin(LORA_FREQ_MHZ, LORA_BW_KHZ, LORA_SF, LORA_CR,
                          LORA_SYNC_WORD, LORA_TX_PWR_DBM, LORA_PREAMBLE);
  if (s != RADIOLIB_ERR_NONE) { Serial.print(F("[HALT] begin=")); Serial.println(s); for(;;)delay(1000); }
  radio.setCurrentLimit(FOX_OCP_MA);

  radio.setPacketReceivedAction(onPacketReceived);
  s = radio.startReceive();
  if (s != RADIOLIB_ERR_NONE) { Serial.print(F("[HALT] startReceive=")); Serial.println(s); for(;;)delay(1000); }

  // OLED — опционально
  Wire.setSDA(I2C_SDA_PIN); Wire.setSCL(I2C_SCL_PIN); Wire.begin();
  Wire.setClock(400000);   // 400 кГц (Fast I2C). Дефолт 100 кГц рисует кадр
                           // SSD1306 ~100 мс и на это время глушит приём радио;
                           // на 400 кГц — ~25 мс. Большинство SSD1306 держат 400к.
                           // Если дисплей глючит/не стартует — верните 100000.
  g_hasOled = oled.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR);
  if (!g_hasOled) Serial.println(F("[OLED] не найден — работаем на слух"));

  pinMode(BUZZER_PIN, OUTPUT); noTone(BUZZER_PIN);

  Serial.println(F("[HUNTER] OK. Асинхронный приём запущен."));
  oledWaiting();
}

void loop() {
  // приём (неблокирующий)
  if (g_rxFlag) {
    g_rxFlag = false;
    uint8_t buf[sizeof(FoxBeacon_t)];
    int16_t s = radio.readData(buf, sizeof(buf));
    // RSSI/SNR/длину читаем СРАЗУ — они относятся к только что принятому пакету
    float   rssi = radio.getRSSI();
    float   snr  = radio.getSNR();
    uint8_t len  = radio.getPacketLength();

    // КРИТИЧНО: возобновляем приём НЕМЕДЛЕННО, ДО обработки/OLED/Serial.
    // Пока мы разбираем пакет, рисуем экран и печатаем лог (это десятки мс),
    // радио уже снова слушает эфир и не теряет следующие пакеты лисы.
    // Раньше startReceive стоял В КОНЦЕ — и охотник глох на всё время
    // отрисовки, пропуская ~19 из 20 пакетов при маяке 300 мс.
    radio.startReceive();

    if (s == RADIOLIB_ERR_NONE) {
      if (len == sizeof(FoxBeacon_t))
        processBeacon((FoxBeacon_t*)buf, rssi, snr, buf, len);
      else { Serial.print(F("[?] чужой пакет len=")); Serial.println(len); }
    } else if (s == RADIOLIB_ERR_CRC_MISMATCH) {
      Serial.println(F("[!] CRC error"));
    } else { Serial.print(F("[!] readData=")); Serial.println(s); }
  }

  // ТАЙМАУТ: сигнал потерян → плавно в тишину
  if (g_rssiCount > 0 && (millis() - g_lastRxMs > SIGNAL_TIMEOUT_MS)) {
    rssiReset();
    g_curFox = 0;
    // Гасим ВСЁ: и обычный зуммер, и незавершённый проговор ID — иначе
    // при следующем пакете доиграется обрубок старого проговора.
    noTone(BUZZER_PIN);
    g_beeping = g_solid = false;
    g_announceLeft = 0; g_announceOn = false;
    Serial.println(F("[..] сигнал потерян — тишина"));
    g_oledDirty = false;
    oledWaiting();
  }

  // ОТРИСОВКА OLED ПО ТАЙМЕРУ — не на каждый пакет. Отрисовка SSD1306 по I2C
  // занимает десятки мс; если делать её в processBeacon, радио глохнет и
  // теряет пакеты. Здесь рисуем максимум раз в OLED_REDRAW_MS, приём не страдает.
  if (g_oledDirty && (millis() - g_lastOledMs > OLED_REDRAW_MS)) {
    g_lastOledMs = millis();
    g_oledDirty  = false;
    oledBeacon(g_dispFox, g_dispRssi, g_dispSnr, g_dispSecure);
  }

  // УРОВЕНЬ ШУМА: когда активного сигнала нет, периодически меряем фон эфира.
  // Помогает осмысленно выставить RSSI_SILENCE: порог должен быть ВЫШЕ шума.
  //
  // ⚠️ ВНИМАНИЕ ПО API: сигнатура getRSSI для замера КАНАЛА (а не пакета)
  //    отличается между версиями RadioLib. Ниже — двухаргументный вариант
  //    getRSSI(skipReceive=false, packet=false). ЕСЛИ НЕ КОМПИЛИРУЕТСЯ —
  //    закомментируйте строку с двумя аргументами и раскомментируйте нужную:
  if (g_rssiCount == 0 && (millis() - g_lastNoiseMs > NOISE_PRINT_MS)) {
    g_lastNoiseMs = millis();

    float noise = radio.getRSSI(false, false);   // ← вариант A (RadioLib 6.x+/7.x)
    // float noise = radio.getRSSI(false);        // ← вариант B, если A не собралась
    // float noise = radio.getRSSI();             // ← вариант C (RSSI последнего пакета — грубее)

    Serial.print(F("[NOISE] floor=")); Serial.print(noise, 1);
    Serial.println(F(" dBm"));
  }

  buzzerUpdate(rssiAvg());
}