Lab045: demonstrate real RF BPSK error correction
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
LittleSam129
@@ -631,3 +631,61 @@ Common-clock preflight PASS: MASTER reg29 = 0x26, SLAVE reg29 = 0x26, SLAVE CLKI
|
|||||||
## Следующий этап
|
## Следующий этап
|
||||||
|
|
||||||
Защитить критические поля кадра от одиночных битовых ошибок при BER ~0.6 %: FEC либо избыточное/помехоустойчивое кодирование PHY LENGTH и protocol-заголовка (ошибка сорвала разбор именно в длине, а не в CRC полезной нагрузки). Только после этого имеет смысл повторный аппаратный прогон Lab044 и переход к более длинным/структурированным передачам.
|
Защитить критические поля кадра от одиночных битовых ошибок при BER ~0.6 %: FEC либо избыточное/помехоустойчивое кодирование PHY LENGTH и protocol-заголовка (ошибка сорвала разбор именно в длине, а не в CRC полезной нагрузки). Только после этого имеет смысл повторный аппаратный прогон Lab044 и переход к более длинным/структурированным передачам.
|
||||||
|
|
||||||
|
# Запись 023
|
||||||
|
|
||||||
|
## Дата
|
||||||
|
|
||||||
|
31 августа 2026 года
|
||||||
|
|
||||||
|
## Тема
|
||||||
|
|
||||||
|
Lab045: программная подготовка bit-level FEC для реального BPSK-пакета.
|
||||||
|
|
||||||
|
## Выполнено
|
||||||
|
|
||||||
|
Реализован свёрточный код R=1/2, K=7 с многочленами 171 и 133 octal, нулевым начальным состоянием и шестью нулевыми tail bits. Soft-decision decoder Витерби использует евклидову branch metric по вещественным BPSK-решениям до hard slicing. Соглашение BPSK сохранено от существующего тракта: бит 0 соответствует минус 1, бит 1 соответствует плюс 1.
|
||||||
|
|
||||||
|
Добавлен детерминированный блочный interleaver с записью строками и чтением столбцами. Перестановка не теряет элементы на неполной последней строке, проверяется как полная биекция и одинаково применяется к coded bits и soft values. Существующий GF(256) erasure FEC 12+3 не менялся и остаётся механизмом более высокого уровня для известных потерянных fragments.
|
||||||
|
|
||||||
|
Весь существующий protocol packet длиной 268 байт, включая 8-байтовый заголовок, 256 байт произвольного payload и CRC32, преобразуется в 2144 information bits и кодируется вместе с шестью tail bits в 4300 coded bits. Protocol parser вызывается только после deinterleave и soft Viterbi; существующий CRC32 остаётся независимым end-to-end решением.
|
||||||
|
|
||||||
|
PHY header расширен до magic, версии, длины packet и 8-битного checksum. Его 48 бит защищены побитовым повторением b,b,b до 144 бит. Majority decoder fail-closed проверяет magic, версию, checksum, предел длины и наличие рассчитанного числа coded symbols до запуска FEC decoder.
|
||||||
|
|
||||||
|
Подготовлен IQ-адаптер поверх доказанного Lab044: независимый PRBS7 detector, timing, CFO и phase/polarity recovery переиспользуются без TX payload, а FEC получает normalized.real до hard slicing. Диагностическое сравнение с TX разрешено отдельной функцией только после независимого CRC verdict.
|
||||||
|
|
||||||
|
Точный кадр Lab045 содержит 5724 BPSK-символа. При 400 samples per symbol и существующих guard/RRC параметрах Lab044 форма содержит 2 306 400 samples и длится 288,3 мс при 8 MS/s. Для сравнения Lab044 содержал 3456 символов, 1 399 200 samples и 174,9 мс.
|
||||||
|
|
||||||
|
Синтетический software-тракт прошёл. В детерминированном опыте с 28 ошибками из 4300 coded bits, BER 0,6512 процента, после FEC осталось 0 ошибок protocol packet, CRC PASS и payload восстановлен точно. Пачка из 14 соседних channel symbols также исправлена. Отдельный AWGN-тест подтвердил реальное использование soft-амплитуд: soft Viterbi дал 0 information-bit errors, тогда как hard baseline по тем же значениям дал 5.
|
||||||
|
|
||||||
|
Полный программный шлюз: `python tools/quick_gate.py` PASS, `python -m pytest tests/ -q` дал 417 passed, 0 failed, 0 skipped, `git diff --check` чист. Подробности, формат кадра и ограничения записаны в `docs/lab045_current_state.md`.
|
||||||
|
|
||||||
|
Аппаратные утилиты в этой сессии не запускались. RF TX = 0, RF RX = 0, hardware validation не выполнялась. Git add, commit и push не выполнялись.
|
||||||
|
|
||||||
|
Следующий этап: после отдельного разрешения подготовить ограниченный аппаратный runner Lab045 на базе common-clock preflight, one-TX guard, артефактов и cleanup Lab044, повторно пройти software gate и только затем рассматривать один аппаратный FEC-прогон.
|
||||||
|
|
||||||
|
# Запись 024
|
||||||
|
|
||||||
|
## Дата
|
||||||
|
|
||||||
|
1 сентября 2026 года
|
||||||
|
|
||||||
|
## Тема
|
||||||
|
|
||||||
|
Lab045: первый аппаратный RF-прогон bit-level FEC — RESULT A, реальная помехоустойчивая коррекция в эфире доказана.
|
||||||
|
|
||||||
|
## Выполнено
|
||||||
|
|
||||||
|
Перед эфиром исправлена устаревшая цифра в Записи 023 (414 → 417 passed) и в документации явно разделены две величины: информационные символы кадра (5724 символа, 2 289 600 отсчётов, 286,2 мс) и фактически сгенерированная форма сигнала (2 306 400 отсчётов, 288,3 мс). Разница в 42 символа (16 800 отсчётов) подтверждена прямо по формирователю shape_frame_like_lab042: 32 нулевых защитных символа (guard, по 16 с каждой стороны) плюс 10 символов длины корневого приподнятого косинуса (переходный хвост фильтра, режим full). Это учётная величина, а не дефект сигнала; форма не менялась. Тот же механизм даёт 1 399 200 отсчётов в Lab044.
|
||||||
|
|
||||||
|
Программный шлюз перед эфиром: quick_gate PASS, pytest 417 passed, git diff --check чист. Обе платы видны, серийники соответствуют ролям.
|
||||||
|
|
||||||
|
Выполнен ровно один аппаратный прогон `python experiments/lab045_hackrf_bpsk_fec.py --hardware --i-understand-hardware`. RF TX count = 1, без повторов. Рабочая точка Lab043/Lab044 без изменений: RF 1080 МГц, 8 MS/s, BPSK 20 ксимв/с, digital carrier +50 кГц, TX VGA 10 дБ, RX LNA/VGA 24/24 дБ, RF amp и bias OFF. Общий опорник: MASTER reg29 = 0x26, SLAVE reg29 = 0x26, SLAVE CLKIN = DETECTED (за 2 опроса, 141,8 мс). RX стартовал до TX; логи TX/RX чистые: 0 overruns, 0 underruns; clipping 0.
|
||||||
|
|
||||||
|
Результат — **RESULT A** с флагом **REAL RF FEC CORRECTION DEMONSTRATED = YES**. Канал в этом прогоне оказался существенно шумнее рабочей точки Lab044: SNR всего 2,63 дБ, ошибок преамбулы 39/1280 (3,05 %). Независимый приёмник (детектор преамбулы, timing, CFO, phase/polarity, мажоритарный PHY header) без доступа к переданным данным извлёк мягкие BPSK-значения. Диагностическое сравнение с TX, разрешённое только после независимого CRC-решения, показало 155 ошибок из 4300 кодированных бит (BER 3,60 %) до FEC. После deinterleave и мягкого декодера Витерби: 0 ошибок пакета (0/2144), 0 ошибок payload (0/2048), 0 байтовых ошибок. CRC PASS, protocol header корректен (SYNC 0xAA55, версия 1, тип 2, sequence 44, payload_length 256). Восстановленный 256-байтный произвольный payload побитово точен: SHA-256 rx_payload.bin совпал с tx_payload.bin (cb9d06fe…), rx_packet.bin совпал с tx_packet.bin (ed5a5713…). Это прямое доказательство: при SNR 2,63 дБ незащищённый пакет Lab044 не прошёл бы CRC, а свёрточный код R=1/2 K=7 с мягким Витерби исправил все реальные ошибки эфира.
|
||||||
|
|
||||||
|
Артефакты: `C:\Users\user\Documents\SDR_Rover_Lab045_raw\20260901_103434_bpsk_fec\`. SHA-256 всех реально созданных бинарных файлов вычислены дважды и совпали; фиктивных файлов не создавалось. Cleanup: MASTER/SLAVE CLKOUT OFF (SLAVE CLKIN «no clock signal detected»), зависших hackrf_transfer нет. Пост-RF шлюз повторно пройден: quick_gate PASS, pytest 417 passed, git diff --check чист. Второй TX не выполнялся. Git add/commit/push не выполнялись: результат сначала смотрит ChatGPT.
|
||||||
|
|
||||||
|
## Следующий этап
|
||||||
|
|
||||||
|
Проанализировать первый аппаратный результат Lab045 (в частности, почему SNR упал до 2,63 дБ против 7,19 дБ в Lab044 — вероятно антенна/связь/положение) и по решению ChatGPT определить, что дальше: закрепление рабочей точки, переход к более длинным/структурированным передачам или к сжатому изображению. Ни FEC/QPSK/JPEG/video, ни второй TX в этой сессии не запускаются.
|
||||||
|
|||||||
217
docs/lab045_current_state.md
Normal file
217
docs/lab045_current_state.md
Normal file
@@ -0,0 +1,217 @@
|
|||||||
|
# Lab045: текущее состояние
|
||||||
|
|
||||||
|
## Статус
|
||||||
|
|
||||||
|
**РЕАЛИЗАЦИЯ ГОТОВА. ПРОГРАММНО ПРОВЕРЕНО. АППАРАТНАЯ ПРОВЕРКА ПРОЙДЕНА
|
||||||
|
(RESULT A). РЕАЛЬНАЯ FEC-КОРРЕКЦИЯ В ЭФИРЕ ДОКАЗАНА.**
|
||||||
|
|
||||||
|
Работа выполнена от фактического HEAD
|
||||||
|
`72f933a32b0dfaef3a4af5bd2cb4a2c` (`Lab044: validate arbitrary BPSK
|
||||||
|
packet reception`). 1 сентября 2026 года выполнен **ровно один** аппаратный
|
||||||
|
RF-прогон Lab045: RF TX count = 1, без повторов.
|
||||||
|
|
||||||
|
## Аппаратный результат (1 сентября 2026 года) — RESULT A
|
||||||
|
|
||||||
|
Каталог артефактов:
|
||||||
|
`C:\Users\user\Documents\SDR_Rover_Lab045_raw\20260901_103434_bpsk_fec\`
|
||||||
|
|
||||||
|
- **RF TX count = 1** (ровно одна передача, `TransmitGuard`, без повторов).
|
||||||
|
- **Инвентарь плат** подтверждён по серийникам: MASTER/TX `…323b97d3`,
|
||||||
|
SLAVE/RX `…2e5327d3`.
|
||||||
|
- **Общий опорный генератор PASS**: MASTER reg29 = 0x26 (38), SLAVE reg29 =
|
||||||
|
0x26 (38), SLAVE CLKIN = DETECTED (за 2 опроса, 141,8 мс).
|
||||||
|
- **Независимая синхронизация по преамбуле PASS**: peak/median +34,3 дБ,
|
||||||
|
peak/second +12,7 дБ, payload не использовался.
|
||||||
|
- **Защищённый PHY header PASS** (packet length = 268 восстановлена
|
||||||
|
мажоритарно, checksum сошёлся).
|
||||||
|
- **Канал был реально шумным**: SNR всего **2,63 дБ**, ошибок преамбулы
|
||||||
|
**39/1280** (BER 3,05 %), сырых ошибок кодированного потока
|
||||||
|
**155/4300** (BER **3,60 %**).
|
||||||
|
- **Свёрточный декодер Витерби исправил все ошибки**: post-FEC ошибок
|
||||||
|
пакета — **0/2144**, ошибок payload — **0/2048**, байтовых ошибок — 0.
|
||||||
|
- **CRC = PASS**, protocol header PASS (SYNC 0xAA55, версия 1, тип 2
|
||||||
|
(телеметрия), sequence 44, payload_length 256).
|
||||||
|
- **Payload восстановлен побитово точно**: SHA-256 `rx_payload.bin`
|
||||||
|
совпал с `tx_payload.bin` (`cb9d06fe…`); `rx_packet.bin` совпал с
|
||||||
|
`tx_packet.bin` (`ed5a5713…`).
|
||||||
|
|
||||||
|
### Главный научный итог
|
||||||
|
|
||||||
|
**REAL RF FEC CORRECTION DEMONSTRATED = YES.** До декодера в реальном
|
||||||
|
принятом сигнале присутствовали 155 ошибок кодированных бит (3,60 %),
|
||||||
|
после мягкого декодера Витерби осталось 0 ошибок, CRC пройден, произвольный
|
||||||
|
256-байтный payload восстановлен без единой ошибки. Это прямое
|
||||||
|
доказательство работы помехоустойчивого кода на реальном радиоканале — при
|
||||||
|
таком SNR незащищённый пакет Lab044 не имел бы шансов пройти CRC.
|
||||||
|
|
||||||
|
### Радиометрика прогона
|
||||||
|
|
||||||
|
CFO 0,128 Гц (общий опорник), phase −133,9°, separation 2,707,
|
||||||
|
timing offset −2 отсчёта. ADC: peak_complex 5,83 code, peak_component 5,0,
|
||||||
|
p99.9 ≈ 4,12 code (headroom 122). Clipping 0, near-int8 0. RX overruns 0,
|
||||||
|
TX underruns 0. BEFORE/DURING/AFTER: RMS после DC 0,832 / 0,874 / 0,846 —
|
||||||
|
на интервале кадра (0,288 с) сигнал слегка выше фона, хвост p99.9 during
|
||||||
|
4,21 против 4,12, перегрузки АЦП нет.
|
||||||
|
|
||||||
|
### Cleanup
|
||||||
|
|
||||||
|
MASTER CLKOUT OFF (SLAVE CLKIN «no clock signal detected»), SLAVE CLKOUT
|
||||||
|
OFF, зависших `hackrf_transfer.exe` нет. SHA-256 всех реально созданных
|
||||||
|
бинарных артефактов вычислены дважды и совпали.
|
||||||
|
|
||||||
|
Пост-RF программный шлюз повторно пройден: quick_gate PASS,
|
||||||
|
`pytest` 417 passed, `git diff --check` чист. Второй TX не выполнялся.
|
||||||
|
|
||||||
|
## Назначение
|
||||||
|
|
||||||
|
Lab045 добавляет исправление неизвестных битовых ошибок внутри принятого
|
||||||
|
радиопакета. Существующий `protocol/packet_erasure_fec.py` не менялся: его
|
||||||
|
GF(256) 12+3 предназначен для восстановления известных потерянных shards на
|
||||||
|
более высоком уровне, а не для исправления неизвестных позиций ошибочных битов.
|
||||||
|
|
||||||
|
Программно доказан тракт:
|
||||||
|
|
||||||
|
`256 произвольных байт -> существующий protocol packet и CRC32 -> MSB-first
|
||||||
|
bits -> convolutional R=1/2, K=7 -> interleaver -> noisy soft BPSK ->
|
||||||
|
deinterleaver -> soft Viterbi -> существующий parser/CRC -> исходный payload`.
|
||||||
|
|
||||||
|
## Свёрточный код
|
||||||
|
|
||||||
|
- `K = 7`, память `m = 6`, 64 состояния.
|
||||||
|
- Скорость `R = 1/2`.
|
||||||
|
- Порождающие многочлены в порядке выходных битов: `G0 = 171 octal`,
|
||||||
|
`G1 = 133 octal`.
|
||||||
|
- Полный регистр: `(input_bit << 6) | state`; в `state` находятся шесть
|
||||||
|
предыдущих входных битов, самый свежий занимает бит 5.
|
||||||
|
- Начальное состояние 0.
|
||||||
|
- К информационным битам добавляются шесть нулевых tail bits.
|
||||||
|
- Финальное состояние решётки 0; traceback начинается только из состояния 0;
|
||||||
|
tail bits удаляются из результата.
|
||||||
|
- BPSK-соглашение совпадает с `protocol.bpsk_radio`: `0 -> -1`, `1 -> +1`.
|
||||||
|
- Soft Viterbi получает вещественные значения до hard slicing. Branch metric:
|
||||||
|
сумма квадратов евклидовых расстояний до ожидаемой пары `{-1,+1}`.
|
||||||
|
|
||||||
|
Encoder проверен не только round trip с decoder: есть фиксированные короткие
|
||||||
|
эталонные векторы и второй независимо записанный reference encoder.
|
||||||
|
|
||||||
|
## Перемежитель
|
||||||
|
|
||||||
|
Детерминированный блочный interleaver записывает индексы строками и читает по
|
||||||
|
столбцам. Для Lab045 используется 64 столбца. Неполная последняя строка не
|
||||||
|
дополняется: отсутствующие ячейки пропускаются, поэтому длина не меняется.
|
||||||
|
Одна и та же permutation применяется к TX bits и обратно к RX soft values.
|
||||||
|
Перед применением проверяется, что каждый индекс встречается ровно один раз.
|
||||||
|
|
||||||
|
## Защищённый PHY header
|
||||||
|
|
||||||
|
Незащищённый header имеет 6 байт, 48 бит:
|
||||||
|
|
||||||
|
- magic `0xD391`, 16 бит;
|
||||||
|
- версия режима Lab045 `1`, 8 бит;
|
||||||
|
- длина существующего protocol packet в байтах, 16 бит;
|
||||||
|
- младшие 8 бит CRC32 предыдущих пяти байт, 8 бит.
|
||||||
|
|
||||||
|
Каждый отдельный header bit передаётся буквально как `b,b,b`; формат не
|
||||||
|
является конкатенацией `header|header|header`. После soft majority выполняется
|
||||||
|
fail-closed проверка magic, версии, checksum и диапазона длины `12..1024`
|
||||||
|
(12 байт равны минимальным header + CRC существующего protocol packet).
|
||||||
|
По принятой длине вычисляется точное число coded symbols. Если их физически не
|
||||||
|
хватает, Viterbi и protocol parser не запускаются. Лишние trailing soft values
|
||||||
|
детерминированно игнорируются.
|
||||||
|
|
||||||
|
## Независимый порядок приёма
|
||||||
|
|
||||||
|
Аппаратный адаптер подготовлен, но не запускался. Он принимает только IQ и
|
||||||
|
переиспользует из Lab044 независимый PRBS7 detector, timing, CFO и
|
||||||
|
phase/polarity recovery. На выходе берётся `normalized.real` до строки hard
|
||||||
|
slicing Lab044. Далее порядок фиксирован:
|
||||||
|
|
||||||
|
`PHY sync -> protected PHY header -> deinterleave soft -> soft Viterbi ->
|
||||||
|
reconstructed protocol packet -> existing parse_packet -> existing CRC`.
|
||||||
|
|
||||||
|
RX analyzer не принимает TX packet или payload. Сравнение pre-FEC, post-FEC и
|
||||||
|
payload с TX вынесено в отдельную диагностическую функцию, вызываемую только
|
||||||
|
после независимого CRC verdict.
|
||||||
|
|
||||||
|
## Точный размер кадра
|
||||||
|
|
||||||
|
| Величина | Значение |
|
||||||
|
|---|---:|
|
||||||
|
| Protocol packet | 268 bytes |
|
||||||
|
| Information bits | 2144 |
|
||||||
|
| Tail bits | 6 |
|
||||||
|
| Входных битов encoder с tail | 2150 |
|
||||||
|
| Coded bits | 4300 |
|
||||||
|
| Interleaver elements | 4300 |
|
||||||
|
| Незащищённый PHY header | 48 bits |
|
||||||
|
| Защищённый PHY header | 144 bits |
|
||||||
|
| PRBS7 preamble | 1280 bits |
|
||||||
|
| Всего BPSK-символов кадра | 5724 |
|
||||||
|
| Samples per symbol | 400 |
|
||||||
|
|
||||||
|
Учёт кадра и формы сигнала — это две разные величины, и их нужно различать:
|
||||||
|
|
||||||
|
| Величина | Символы | Отсчёты | Длительность при 8 MS/s |
|
||||||
|
|---|---|---|---|
|
||||||
|
| **Только информационные BPSK-символы кадра** | 5724 | 2 289 600 | 286,2 мс |
|
||||||
|
| **Фактически сгенерированная форма сигнала** | 5766 | 2 306 400 | 288,3 мс |
|
||||||
|
| Разница | 42 | 16 800 | 2,1 мс |
|
||||||
|
|
||||||
|
Откуда берётся разница в 42 символа (16 800 отсчётов) — подтверждено прямо по
|
||||||
|
формирователю `shape_frame_like_lab042` (свёртка `guard + upsampled + guard`
|
||||||
|
с ФРК-фильтром в режиме `full`, длина = `(N + 2·guard + span)·sps`):
|
||||||
|
|
||||||
|
- **32 символа** — защитные интервалы Lab042 (`LAB042_GUARD_SYMBOL_COUNT = 16`
|
||||||
|
с каждой стороны, до и после кадра);
|
||||||
|
- **10 символов** — длина корневого приподнятого косинуса (ФРК)
|
||||||
|
`LAB042_RRC_SPAN_SYMBOLS = 10` (переходный хвост фильтра от режима `full`).
|
||||||
|
|
||||||
|
Это не guard/RRC «на веру» и не дефект сигнала: это ровно тот же механизм
|
||||||
|
формирования, что и в проверенном Lab044, где 3456 символов кадра дают
|
||||||
|
1 399 200 отсчётов = (3456 + 42)·400. Форму сигнала менять не нужно.
|
||||||
|
|
||||||
|
Для сравнения Lab044: кадр 3456 символов, форма 1 399 200 отсчётов, 174,9 мс.
|
||||||
|
Lab045 добавляет к кадру 2268 символов. Старая оценка около 280 мс для Lab044
|
||||||
|
не используется.
|
||||||
|
|
||||||
|
## Фактические программные результаты
|
||||||
|
|
||||||
|
- Новый набор `tests/test_lab045_hackrf_bpsk_fec.py`: 41 passed.
|
||||||
|
- Идеальный soft BPSK: CRC PASS, payload совпал побайтово.
|
||||||
|
- Детерминированный канал с `bit_error_probability=0.006`, seed 7: до FEC
|
||||||
|
28 ошибок из 4300 coded bits (`BER = 0.0065116`), после FEC 0 ошибок в
|
||||||
|
protocol packet, CRC PASS, payload точный.
|
||||||
|
- Пачка из 14 соседних channel symbols: после interleaver/FEC CRC PASS,
|
||||||
|
payload точный.
|
||||||
|
- Детерминированный Gaussian noise с `sigma=0.45`, seed 45: CRC PASS.
|
||||||
|
- На отдельном честном AWGN-примере из 128 information bits hard slicing дал
|
||||||
|
15 channel-bit errors и после hard Viterbi осталось 5 information-bit
|
||||||
|
errors; soft Viterbi по тем же значениям дал 0 information-bit errors.
|
||||||
|
Это доказывает использование амплитудной информации, но не является
|
||||||
|
измерением выигрыша в dB реального канала.
|
||||||
|
- Синтетическая cs8 IQ-форма прошла тот же detector/timing/CFO/phase adapter,
|
||||||
|
что Lab044: PHY sync PASS, CRC PASS, payload точный.
|
||||||
|
- Majority, checksum, bad magic, bad version, impossible length, truncated
|
||||||
|
header/body, extra trailing data, CRC corruption и отсутствие TX-data
|
||||||
|
leakage покрыты отдельными тестами.
|
||||||
|
|
||||||
|
## Software gate
|
||||||
|
|
||||||
|
- `python tools/quick_gate.py`: PASS; 414 тестов ядра, 5 функциональных
|
||||||
|
проверок лаб, 13 штатно пропущенных проверок.
|
||||||
|
- `python -m pytest tests/ -q`: 414 passed, 0 failed, 0 skipped.
|
||||||
|
- `git diff --check`: PASS.
|
||||||
|
- Pytest сообщил только предупреждение о невозможности создать `.pytest_cache`
|
||||||
|
из-за прав каталога; на выполнение и итог тестов это не повлияло.
|
||||||
|
|
||||||
|
## Ограничения и следующий шаг
|
||||||
|
|
||||||
|
`run_hardware_experiment()` намеренно завершается `NotImplementedError`, а CLI
|
||||||
|
с `--hardware` возвращает ненулевой код и печатает `RF TX = 0`. Аппаратный
|
||||||
|
Lab045, повтор Lab044, gain tuning, QPSK, JPEG и video в этой сессии не
|
||||||
|
выполнялись.
|
||||||
|
|
||||||
|
Следующий этап возможен только по отдельному разрешению: дополнить аппаратную
|
||||||
|
обвязку Lab045 доказанными common-clock preflight, one-TX guard, artifact и
|
||||||
|
cleanup механизмами Lab044, повторно пройти software gate и выполнить один
|
||||||
|
ограниченный аппаратный прогон.
|
||||||
1072
experiments/lab045_hackrf_bpsk_fec.py
Normal file
1072
experiments/lab045_hackrf_bpsk_fec.py
Normal file
File diff suppressed because it is too large
Load Diff
86
protocol/bit_interleaver.py
Normal file
86
protocol/bit_interleaver.py
Normal file
@@ -0,0 +1,86 @@
|
|||||||
|
"""Детерминированный блочный перемежитель (запись строками, чтение столбцами).
|
||||||
|
|
||||||
|
Перемежитель декоррелирует пачки ошибок канала: соседние по входу элементы
|
||||||
|
после перестановки оказываются разнесены, а пачка подряд идущих ошибок
|
||||||
|
канала после обратной перестановки распадается на разрозненные одиночные
|
||||||
|
ошибки, которые свёрточный код исправляет лучше всего.
|
||||||
|
|
||||||
|
Схема. Для длины ``length`` и числа столбцов ``columns`` элементы условно
|
||||||
|
записываются построчно в матрицу ``rows × columns`` (``rows =
|
||||||
|
ceil(length/columns)``) и считываются по столбцам. Если длина не кратна
|
||||||
|
размеру матрицы, недостающие ячейки последнего ряда просто пропускаются —
|
||||||
|
ни один элемент не теряется и не выдумывается. Результат выражен как
|
||||||
|
перестановка индексов ``permutation`` длиной ``length``: перемежённый
|
||||||
|
поток ``output[k] = input[permutation[k]]``. Обратная операция применяет
|
||||||
|
обратную перестановку и работает как с битами, так и напрямую с soft-
|
||||||
|
значениями BPSK на приёме. Перестановка зависит только от ``length`` и
|
||||||
|
``columns`` и не зависит от передаваемых данных.
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import numpy as np
|
||||||
|
|
||||||
|
|
||||||
|
def _validated_permutation(permutation: np.ndarray, length: int) -> np.ndarray:
|
||||||
|
"""Проверить, что перестановка содержит каждый допустимый индекс один раз."""
|
||||||
|
|
||||||
|
raw_permutation = np.asarray(permutation)
|
||||||
|
if raw_permutation.ndim != 1:
|
||||||
|
raise ValueError("permutation должен быть одномерным")
|
||||||
|
if len(raw_permutation) != length:
|
||||||
|
raise ValueError("длина values не совпадает с длиной перестановки")
|
||||||
|
if not np.issubdtype(raw_permutation.dtype, np.integer):
|
||||||
|
raise ValueError("permutation должен содержать целые индексы")
|
||||||
|
checked = raw_permutation.astype(np.int64, copy=False)
|
||||||
|
if not np.array_equal(np.sort(checked), np.arange(length, dtype=np.int64)):
|
||||||
|
raise ValueError("permutation не является полной перестановкой индексов")
|
||||||
|
return checked
|
||||||
|
|
||||||
|
|
||||||
|
def build_permutation(length: int, columns: int) -> np.ndarray:
|
||||||
|
"""Построить перестановку чтения по столбцам для блока длиной ``length``.
|
||||||
|
|
||||||
|
Возвращает одномерный массив индексов длиной ``length``: ``output[k] =
|
||||||
|
input[permutation[k]]``. Гарантируется, что каждый индекс 0..length-1
|
||||||
|
встречается ровно один раз.
|
||||||
|
"""
|
||||||
|
|
||||||
|
if not isinstance(length, (int, np.integer)) or length < 1:
|
||||||
|
raise ValueError("length должен быть положительным целым")
|
||||||
|
if not isinstance(columns, (int, np.integer)) or columns < 1:
|
||||||
|
raise ValueError("columns должен быть положительным целым")
|
||||||
|
columns = int(columns)
|
||||||
|
length = int(length)
|
||||||
|
rows = (length + columns - 1) // columns
|
||||||
|
permutation = [
|
||||||
|
row * columns + column
|
||||||
|
for column in range(columns)
|
||||||
|
for row in range(rows)
|
||||||
|
if row * columns + column < length
|
||||||
|
]
|
||||||
|
result = np.asarray(permutation, dtype=np.int64)
|
||||||
|
assert len(result) == length
|
||||||
|
return result
|
||||||
|
|
||||||
|
|
||||||
|
def interleave(values: np.ndarray, permutation: np.ndarray) -> np.ndarray:
|
||||||
|
"""Применить перестановку: ``output[k] = values[permutation[k]]``."""
|
||||||
|
|
||||||
|
values = np.asarray(values)
|
||||||
|
if values.ndim != 1:
|
||||||
|
raise ValueError("values должен быть одномерным")
|
||||||
|
checked_permutation = _validated_permutation(permutation, len(values))
|
||||||
|
return values[checked_permutation]
|
||||||
|
|
||||||
|
|
||||||
|
def deinterleave(values: np.ndarray, permutation: np.ndarray) -> np.ndarray:
|
||||||
|
"""Обратить перестановку без потери типа (работает и с soft-значениями)."""
|
||||||
|
|
||||||
|
values = np.asarray(values)
|
||||||
|
if values.ndim != 1:
|
||||||
|
raise ValueError("values должен быть одномерным")
|
||||||
|
checked_permutation = _validated_permutation(permutation, len(values))
|
||||||
|
restored = np.empty_like(values)
|
||||||
|
restored[checked_permutation] = values
|
||||||
|
return restored
|
||||||
216
protocol/convolutional_fec.py
Normal file
216
protocol/convolutional_fec.py
Normal file
@@ -0,0 +1,216 @@
|
|||||||
|
"""Свёрточный код R=1/2, K=7 и soft-decision декодер Витерби.
|
||||||
|
|
||||||
|
Настоящий помехоустойчивый код уровня бит для исправления неизвестных
|
||||||
|
битовых ошибок реального BPSK-канала (Lab044 показал BER ≈0.5–0.6%, при
|
||||||
|
котором незащищённый пакет практически не проходит CRC). В отличие от
|
||||||
|
``protocol/packet_erasure_fec`` (GF(256), только стирания), этот код
|
||||||
|
исправляет случайные битовые ошибки без знания их позиций.
|
||||||
|
|
||||||
|
Параметры зафиксированы и не передаются в каждом кадре:
|
||||||
|
|
||||||
|
- constraint length ``K = 7``; память ``m = 6``; число состояний ``2**6 = 64``;
|
||||||
|
- скорость ``R = 1/2`` (два выходных бита на один входной);
|
||||||
|
- порождающие многочлены ``G0 = 0o171``, ``G1 = 0o133`` (стандарт NASA/Voyager);
|
||||||
|
- начальное состояние регистра ``0``;
|
||||||
|
- терминирование: к информационным битам добавляются ``m = 6`` нулевых
|
||||||
|
хвостовых бита, так что финальное состояние тоже ``0``.
|
||||||
|
|
||||||
|
Соглашение сдвигового регистра. Полный 7-битный регистр для вычисления
|
||||||
|
выхода собирается как ``full = (input_bit << 6) | state``, где ``state`` —
|
||||||
|
6 предыдущих входных битов, самый свежий в бите 5, самый старый в бите 0.
|
||||||
|
Порождающий многочлен применяется как битовая маска этого 7-битного
|
||||||
|
регистра, выходной бит = чётность числа единиц. Новое состояние =
|
||||||
|
``full >> 1`` (самый старый бит вытесняется). Такое соглашение проверяется
|
||||||
|
независимо посчитанными эталонными векторами в
|
||||||
|
``tests/test_lab045_hackrf_bpsk_fec.py``.
|
||||||
|
|
||||||
|
Соответствие BPSK (совпадает с ``protocol/bpsk_radio.bpsk_modulate``):
|
||||||
|
бит ``0`` → символ ``-1``, бит ``1`` → символ ``+1``. Декодер работает с
|
||||||
|
soft-значениями BPSK (проекция принятого символа на решающую ось,
|
||||||
|
``normalized.real`` в Lab044) и использует евклидову ветвевую метрику к
|
||||||
|
ожидаемым символам ``{-1, +1}``. Hard-decision — частный случай: знаки
|
||||||
|
soft-значений.
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import numpy as np
|
||||||
|
|
||||||
|
CONSTRAINT_LENGTH = 7
|
||||||
|
MEMORY = CONSTRAINT_LENGTH - 1 # 6
|
||||||
|
STATE_COUNT = 1 << MEMORY # 64
|
||||||
|
GENERATOR_POLYNOMIALS_OCTAL = (0o171, 0o133) # (171, 133) octal
|
||||||
|
OUTPUTS_PER_INPUT = len(GENERATOR_POLYNOMIALS_OCTAL) # 2
|
||||||
|
TAIL_BIT_COUNT = MEMORY # 6
|
||||||
|
CODE_RATE = (1, OUTPUTS_PER_INPUT) # 1/2
|
||||||
|
|
||||||
|
_STATE_MASK = STATE_COUNT - 1 # 0x3F
|
||||||
|
_INPUT_BIT_POSITION = MEMORY # входной бит занимает бит 6 полного регистра
|
||||||
|
_LOWER_STATE_MASK = (1 << (MEMORY - 1)) - 1 # 0x1F, младшие 5 бит состояния
|
||||||
|
|
||||||
|
|
||||||
|
def _parity(value: int) -> int:
|
||||||
|
"""Чётность числа установленных битов (0 или 1)."""
|
||||||
|
|
||||||
|
return bin(value).count("1") & 1
|
||||||
|
|
||||||
|
|
||||||
|
def _next_state(state: int, input_bit: int) -> int:
|
||||||
|
full = (input_bit << _INPUT_BIT_POSITION) | state
|
||||||
|
return full >> 1
|
||||||
|
|
||||||
|
|
||||||
|
def _output_bits(state: int, input_bit: int) -> tuple[int, ...]:
|
||||||
|
full = (input_bit << _INPUT_BIT_POSITION) | state
|
||||||
|
return tuple(_parity(full & generator) for generator in GENERATOR_POLYNOMIALS_OCTAL)
|
||||||
|
|
||||||
|
|
||||||
|
def _build_decode_tables() -> tuple[np.ndarray, np.ndarray]:
|
||||||
|
"""Предвычислить предшественников и ожидаемые символы для решётки.
|
||||||
|
|
||||||
|
Для каждого следующего состояния ``next_state`` вход, приведший в него,
|
||||||
|
однозначен и равен старшему биту состояния (бит 5). У ``next_state``
|
||||||
|
ровно два предшественника, различающиеся вытесненным младшим битом.
|
||||||
|
Возвращает ``predecessors[next_state, branch]`` и
|
||||||
|
``symbols[next_state, branch, output_index]`` со значениями в {-1, +1}.
|
||||||
|
"""
|
||||||
|
|
||||||
|
predecessors = np.zeros((STATE_COUNT, 2), dtype=np.int64)
|
||||||
|
symbols = np.zeros((STATE_COUNT, 2, OUTPUTS_PER_INPUT), dtype=np.float64)
|
||||||
|
for next_state in range(STATE_COUNT):
|
||||||
|
input_bit = next_state >> (MEMORY - 1) # старший бит состояния
|
||||||
|
base = (next_state & _LOWER_STATE_MASK) << 1
|
||||||
|
for branch in range(2):
|
||||||
|
previous_state = base | branch
|
||||||
|
assert _next_state(previous_state, input_bit) == next_state
|
||||||
|
predecessors[next_state, branch] = previous_state
|
||||||
|
output = _output_bits(previous_state, input_bit)
|
||||||
|
for output_index, bit in enumerate(output):
|
||||||
|
symbols[next_state, branch, output_index] = 2.0 * bit - 1.0
|
||||||
|
return predecessors, symbols
|
||||||
|
|
||||||
|
|
||||||
|
_PREDECESSORS, _BRANCH_SYMBOLS = _build_decode_tables()
|
||||||
|
_BRANCH_SYMBOL_0 = _BRANCH_SYMBOLS[:, :, 0]
|
||||||
|
_BRANCH_SYMBOL_1 = _BRANCH_SYMBOLS[:, :, 1]
|
||||||
|
|
||||||
|
|
||||||
|
def _validate_information_bits(information_bits: np.ndarray) -> np.ndarray:
|
||||||
|
raw_bits = np.asarray(information_bits)
|
||||||
|
if raw_bits.ndim != 1:
|
||||||
|
raise ValueError("information_bits должен быть одномерным")
|
||||||
|
if raw_bits.size == 0:
|
||||||
|
raise ValueError("information_bits не должен быть пустым")
|
||||||
|
if not np.all((raw_bits == 0) | (raw_bits == 1)):
|
||||||
|
raise ValueError("information_bits должен содержать только 0 и 1")
|
||||||
|
return raw_bits.astype(np.uint8, copy=False)
|
||||||
|
|
||||||
|
|
||||||
|
def encoded_bit_count(information_bit_count: int) -> int:
|
||||||
|
"""Число кодовых битов для заданного числа информационных битов."""
|
||||||
|
|
||||||
|
if not isinstance(information_bit_count, (int, np.integer)):
|
||||||
|
raise TypeError("information_bit_count должен быть целым")
|
||||||
|
if information_bit_count < 0:
|
||||||
|
raise ValueError("information_bit_count не может быть отрицательным")
|
||||||
|
return OUTPUTS_PER_INPUT * (information_bit_count + TAIL_BIT_COUNT)
|
||||||
|
|
||||||
|
|
||||||
|
def encode(information_bits: np.ndarray) -> np.ndarray:
|
||||||
|
"""Свёрточно закодировать биты, добавив внутреннее терминирование.
|
||||||
|
|
||||||
|
Вход — одномерные биты {0,1}. К ним добавляются ``TAIL_BIT_COUNT``
|
||||||
|
нулевых хвостовых бита, регистр стартует из нуля и заканчивает в нуле.
|
||||||
|
Выход — одномерные кодовые биты {0,1} длиной ``2*(len+6)``.
|
||||||
|
"""
|
||||||
|
|
||||||
|
bits = _validate_information_bits(information_bits)
|
||||||
|
terminated = np.concatenate((bits, np.zeros(TAIL_BIT_COUNT, dtype=np.uint8)))
|
||||||
|
output = np.empty(OUTPUTS_PER_INPUT * len(terminated), dtype=np.uint8)
|
||||||
|
state = 0
|
||||||
|
for index, input_bit in enumerate(int(bit) for bit in terminated):
|
||||||
|
full = (input_bit << _INPUT_BIT_POSITION) | state
|
||||||
|
for output_index, generator in enumerate(GENERATOR_POLYNOMIALS_OCTAL):
|
||||||
|
output[OUTPUTS_PER_INPUT * index + output_index] = _parity(full & generator)
|
||||||
|
state = full >> 1
|
||||||
|
assert state == 0
|
||||||
|
return output
|
||||||
|
|
||||||
|
|
||||||
|
def viterbi_decode_soft(
|
||||||
|
soft_values: np.ndarray,
|
||||||
|
information_bit_count: int,
|
||||||
|
) -> np.ndarray:
|
||||||
|
"""Декодировать soft-значения BPSK терминированным Витерби.
|
||||||
|
|
||||||
|
``soft_values`` — одномерный массив вещественных решающих значений
|
||||||
|
(в идеале ±1, реально ``normalized.real``), длиной ровно
|
||||||
|
``encoded_bit_count(information_bit_count)``. Метрика ветви — евклидово
|
||||||
|
расстояние до ожидаемых символов {-1, +1}. Решётка терминирована:
|
||||||
|
старт и финиш в состоянии 0, хвостовые биты отбрасываются. Возвращает
|
||||||
|
``information_bit_count`` информационных битов. TX-данные не используются.
|
||||||
|
"""
|
||||||
|
|
||||||
|
if not isinstance(information_bit_count, (int, np.integer)):
|
||||||
|
raise TypeError("information_bit_count должен быть целым")
|
||||||
|
if information_bit_count <= 0:
|
||||||
|
raise ValueError("information_bit_count должен быть положительным")
|
||||||
|
information_bit_count = int(information_bit_count)
|
||||||
|
values = np.asarray(soft_values, dtype=np.float64)
|
||||||
|
if values.ndim != 1:
|
||||||
|
raise ValueError("soft_values должен быть одномерным")
|
||||||
|
if not np.all(np.isfinite(values)):
|
||||||
|
raise ValueError("soft_values должен содержать только конечные значения")
|
||||||
|
expected_length = encoded_bit_count(information_bit_count)
|
||||||
|
if len(values) != expected_length:
|
||||||
|
raise ValueError(
|
||||||
|
f"soft_values имеет длину {len(values)}, ожидалось {expected_length}"
|
||||||
|
)
|
||||||
|
|
||||||
|
step_count = information_bit_count + TAIL_BIT_COUNT
|
||||||
|
received = values.reshape(step_count, OUTPUTS_PER_INPUT)
|
||||||
|
|
||||||
|
infinity = np.float64(1e18)
|
||||||
|
path_metric = np.full(STATE_COUNT, infinity, dtype=np.float64)
|
||||||
|
path_metric[0] = 0.0
|
||||||
|
branch_choice = np.empty((step_count, STATE_COUNT), dtype=np.uint8)
|
||||||
|
|
||||||
|
for step in range(step_count):
|
||||||
|
received_0 = received[step, 0]
|
||||||
|
received_1 = received[step, 1]
|
||||||
|
branch_metric = (
|
||||||
|
(received_0 - _BRANCH_SYMBOL_0) ** 2
|
||||||
|
+ (received_1 - _BRANCH_SYMBOL_1) ** 2
|
||||||
|
) # (STATE_COUNT, 2)
|
||||||
|
candidate = path_metric[_PREDECESSORS] + branch_metric # (STATE_COUNT, 2)
|
||||||
|
chosen = np.argmin(candidate, axis=1).astype(np.uint8)
|
||||||
|
path_metric = candidate[np.arange(STATE_COUNT), chosen]
|
||||||
|
branch_choice[step] = chosen
|
||||||
|
|
||||||
|
# Терминированный трекбэк из состояния 0.
|
||||||
|
decoded = np.empty(step_count, dtype=np.uint8)
|
||||||
|
current_state = 0
|
||||||
|
for step in range(step_count - 1, -1, -1):
|
||||||
|
branch = branch_choice[step, current_state]
|
||||||
|
decoded[step] = current_state >> (MEMORY - 1)
|
||||||
|
current_state = int(_PREDECESSORS[current_state, branch])
|
||||||
|
assert current_state == 0
|
||||||
|
return decoded[:information_bit_count]
|
||||||
|
|
||||||
|
|
||||||
|
def viterbi_decode_hard(
|
||||||
|
coded_bits: np.ndarray,
|
||||||
|
information_bit_count: int,
|
||||||
|
) -> np.ndarray:
|
||||||
|
"""Hard-decision вариант: биты {0,1} отображаются в ±1 и декодируются.
|
||||||
|
|
||||||
|
Служит базовой линией для честного сравнения soft и hard в тестах.
|
||||||
|
"""
|
||||||
|
|
||||||
|
raw_bits = np.asarray(coded_bits)
|
||||||
|
if raw_bits.ndim != 1:
|
||||||
|
raise ValueError("coded_bits должен быть одномерным")
|
||||||
|
if not np.all((raw_bits == 0) | (raw_bits == 1)):
|
||||||
|
raise ValueError("coded_bits должен содержать только 0 и 1")
|
||||||
|
bits = raw_bits.astype(np.uint8, copy=False)
|
||||||
|
return viterbi_decode_soft(2.0 * bits.astype(np.float64) - 1.0, information_bit_count)
|
||||||
705
tests/test_lab045_hackrf_bpsk_fec.py
Normal file
705
tests/test_lab045_hackrf_bpsk_fec.py
Normal file
@@ -0,0 +1,705 @@
|
|||||||
|
"""Синтетические end-to-end тесты Lab045 со свёрточной FEC поверх BPSK.
|
||||||
|
|
||||||
|
Без аппаратуры и данных эксперимента. Свёрточный код проверяется вторым,
|
||||||
|
независимо записанным encoder и вручную рассчитанными reference vectors, а не
|
||||||
|
только своим decoder. Полный тракт проверяется на идеальном, ошибочном,
|
||||||
|
пакетном и noisy soft каналах.
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import struct
|
||||||
|
|
||||||
|
import numpy as np
|
||||||
|
import pytest
|
||||||
|
|
||||||
|
from experiments import lab044_hackrf_bpsk_packet as lab044
|
||||||
|
from experiments import lab045_hackrf_bpsk_fec as lab045
|
||||||
|
from protocol import bit_interleaver as interleaver
|
||||||
|
from protocol import bpsk_radio as radio
|
||||||
|
from protocol import convolutional_fec as conv
|
||||||
|
from protocol.packet import HEADER_SIZE, build_packet
|
||||||
|
|
||||||
|
|
||||||
|
def deterministic_payload() -> bytes:
|
||||||
|
return bytes(range(256))
|
||||||
|
|
||||||
|
|
||||||
|
# ---- Независимый reference encoder с другой реализацией ----------------------
|
||||||
|
|
||||||
|
|
||||||
|
def independent_convolutional_encode(information_bits: list[int]) -> list[int]:
|
||||||
|
"""Второй вручную записанный encoder для независимой проверки.
|
||||||
|
|
||||||
|
Список state содержит шесть предыдущих входных битов, начиная с самого
|
||||||
|
свежего. Регистр шага равен [current, prev0..prev4, prev5], а биты
|
||||||
|
многочлена читаются MSB-first.
|
||||||
|
"""
|
||||||
|
|
||||||
|
generators = (0o171, 0o133)
|
||||||
|
bits = list(information_bits) + [0] * conv.TAIL_BIT_COUNT
|
||||||
|
state = [0] * conv.MEMORY
|
||||||
|
output: list[int] = []
|
||||||
|
for current in bits:
|
||||||
|
register = [current] + state # 7 entries, index 0 = current (bit 6)
|
||||||
|
for generator in generators:
|
||||||
|
generator_bits = [(generator >> k) & 1 for k in range(conv.CONSTRAINT_LENGTH - 1, -1, -1)]
|
||||||
|
output.append(sum(a & b for a, b in zip(register, generator_bits)) & 1)
|
||||||
|
state = register[: conv.MEMORY] # drop oldest -> new state
|
||||||
|
return output
|
||||||
|
|
||||||
|
|
||||||
|
# ---- Корректность свёрточного кода -------------------------------------------
|
||||||
|
|
||||||
|
|
||||||
|
def test_encode_matches_hand_computed_impulse_response() -> None:
|
||||||
|
# Импульсная характеристика (171,133) и 6 tail zeros, рассчитана вручную.
|
||||||
|
expected = [1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1]
|
||||||
|
result = conv.encode(np.array([1], dtype=np.uint8))
|
||||||
|
assert result.tolist() == expected
|
||||||
|
|
||||||
|
|
||||||
|
@pytest.mark.parametrize(
|
||||||
|
("information", "expected_coded"),
|
||||||
|
[
|
||||||
|
([0], "00000000000000"),
|
||||||
|
([1, 0], "1110111100011100"),
|
||||||
|
([0, 1], "0011101111000111"),
|
||||||
|
([1, 1], "1101010011011011"),
|
||||||
|
([1, 0, 1], "111000011110110111"),
|
||||||
|
],
|
||||||
|
)
|
||||||
|
def test_encode_matches_short_reference_vectors(
|
||||||
|
information: list[int],
|
||||||
|
expected_coded: str,
|
||||||
|
) -> None:
|
||||||
|
"""Короткие фиксированные векторы защищают соглашение независимо от decoder."""
|
||||||
|
|
||||||
|
result = conv.encode(np.asarray(information, dtype=np.uint8))
|
||||||
|
assert "".join(str(bit) for bit in result.tolist()) == expected_coded
|
||||||
|
|
||||||
|
|
||||||
|
def test_encode_all_zero_is_all_zero() -> None:
|
||||||
|
result = conv.encode(np.zeros(20, dtype=np.uint8))
|
||||||
|
assert result.tolist() == [0] * conv.encoded_bit_count(20)
|
||||||
|
|
||||||
|
|
||||||
|
def test_encode_all_one_matches_independent_reference() -> None:
|
||||||
|
information = [1] * 17
|
||||||
|
assert conv.encode(np.array(information, dtype=np.uint8)).tolist() == independent_convolutional_encode(information)
|
||||||
|
|
||||||
|
|
||||||
|
def test_encode_random_matches_independent_reference() -> None:
|
||||||
|
generator = np.random.default_rng(45)
|
||||||
|
for _ in range(8):
|
||||||
|
information = generator.integers(0, 2, generator.integers(1, 300)).astype(np.uint8)
|
||||||
|
assert conv.encode(information).tolist() == independent_convolutional_encode(information.tolist())
|
||||||
|
|
||||||
|
|
||||||
|
def test_encode_rejects_empty_and_invalid() -> None:
|
||||||
|
with pytest.raises(ValueError):
|
||||||
|
conv.encode(np.array([], dtype=np.uint8))
|
||||||
|
with pytest.raises(ValueError):
|
||||||
|
conv.encode(np.array([2, 0, 1], dtype=np.uint8))
|
||||||
|
with pytest.raises(ValueError):
|
||||||
|
conv.encode(np.zeros((2, 3), dtype=np.uint8))
|
||||||
|
with pytest.raises(ValueError):
|
||||||
|
conv.encode(np.array([256, 0, 1]))
|
||||||
|
with pytest.raises(ValueError):
|
||||||
|
conv.encode(np.array([-1, 0, 1]))
|
||||||
|
|
||||||
|
|
||||||
|
def test_ideal_soft_round_trip_is_exact() -> None:
|
||||||
|
generator = np.random.default_rng(7)
|
||||||
|
information = generator.integers(0, 2, 2144).astype(np.uint8)
|
||||||
|
coded = conv.encode(information)
|
||||||
|
soft = 2.0 * coded.astype(np.float64) - 1.0
|
||||||
|
decoded = conv.viterbi_decode_soft(soft, len(information))
|
||||||
|
assert np.array_equal(decoded, information)
|
||||||
|
|
||||||
|
|
||||||
|
def test_tail_termination_lengths_are_exact() -> None:
|
||||||
|
information = np.ones(100, dtype=np.uint8)
|
||||||
|
coded = conv.encode(information)
|
||||||
|
assert len(coded) == conv.encoded_bit_count(100) == 2 * (100 + 6)
|
||||||
|
decoded = conv.viterbi_decode_soft(2.0 * coded - 1.0, 100)
|
||||||
|
assert len(decoded) == 100
|
||||||
|
|
||||||
|
|
||||||
|
def test_viterbi_rejects_wrong_length() -> None:
|
||||||
|
with pytest.raises(ValueError):
|
||||||
|
conv.viterbi_decode_soft(np.zeros(10, dtype=np.float64), 100)
|
||||||
|
with pytest.raises(ValueError):
|
||||||
|
conv.viterbi_decode_soft(np.zeros(12, dtype=np.float64), 0)
|
||||||
|
with pytest.raises(ValueError):
|
||||||
|
conv.viterbi_decode_soft(np.array([np.nan] * 14), 1)
|
||||||
|
with pytest.raises(ValueError):
|
||||||
|
conv.viterbi_decode_hard(np.array([256] * 14), 1)
|
||||||
|
|
||||||
|
|
||||||
|
def test_bpsk_mapping_matches_existing_radio_primitive() -> None:
|
||||||
|
bits = np.array([0, 1, 1, 0], dtype=np.uint8)
|
||||||
|
expected = np.array([-1.0, 1.0, 1.0, -1.0])
|
||||||
|
assert np.array_equal(lab045.modulate_bits_to_ideal_soft(bits), expected)
|
||||||
|
assert np.array_equal(radio.bpsk_modulate(bits), expected)
|
||||||
|
|
||||||
|
|
||||||
|
def test_single_and_multiple_coded_errors_are_corrected() -> None:
|
||||||
|
generator = np.random.default_rng(11)
|
||||||
|
information = generator.integers(0, 2, 512).astype(np.uint8)
|
||||||
|
coded = conv.encode(information)
|
||||||
|
soft = 2.0 * coded.astype(np.float64) - 1.0
|
||||||
|
for error_count in (1, 3, 8):
|
||||||
|
corrupted = soft.copy()
|
||||||
|
positions = generator.choice(len(corrupted), error_count, replace=False)
|
||||||
|
corrupted[positions] = -corrupted[positions]
|
||||||
|
assert np.array_equal(conv.viterbi_decode_soft(corrupted, len(information)), information)
|
||||||
|
|
||||||
|
|
||||||
|
# ---- Перемежитель ------------------------------------------------------------
|
||||||
|
|
||||||
|
|
||||||
|
def test_interleaver_inverse_and_permutation_are_exact() -> None:
|
||||||
|
for length, columns in [(1, 1), (2, 3), (7, 3), (97, 10), (101, 13), (4300, 64)]:
|
||||||
|
permutation = interleaver.build_permutation(length, columns)
|
||||||
|
assert np.array_equal(np.sort(permutation), np.arange(length))
|
||||||
|
values = np.arange(length, dtype=np.float64) - 0.5
|
||||||
|
restored = interleaver.deinterleave(interleaver.interleave(values, permutation), permutation)
|
||||||
|
assert np.array_equal(restored, values)
|
||||||
|
|
||||||
|
|
||||||
|
def test_interleaver_rejects_malformed_permutations() -> None:
|
||||||
|
values = np.arange(4)
|
||||||
|
with pytest.raises(ValueError):
|
||||||
|
interleaver.interleave(values, np.array([0, 1, 1, 3]))
|
||||||
|
with pytest.raises(ValueError):
|
||||||
|
interleaver.deinterleave(values, np.array([0, 1, 2, 4]))
|
||||||
|
with pytest.raises(ValueError):
|
||||||
|
interleaver.interleave(values, np.array([0.0, 1.0, 2.0, 3.0]))
|
||||||
|
|
||||||
|
|
||||||
|
# ---- Полный тракт Lab045 -----------------------------------------------------
|
||||||
|
|
||||||
|
|
||||||
|
def test_full_chain_ideal_recovers_payload_and_crc() -> None:
|
||||||
|
plan = lab045.build_transmission_plan(deterministic_payload())
|
||||||
|
assert plan.frame_symbol_count == 1280 + 144 + 4300 # 5724
|
||||||
|
soft = lab045.simulate_soft_channel(plan)
|
||||||
|
reception = lab045.analyze_post_preamble_soft(soft)
|
||||||
|
assert reception.analysis["classification"] == "A"
|
||||||
|
assert reception.analysis["crc"] == lab045.CRC_PASS
|
||||||
|
assert reception.payload_bytes == plan.payload
|
||||||
|
assert plan.waveform_sample_count == 2_306_400
|
||||||
|
assert plan.airtime_seconds == pytest.approx(0.2883)
|
||||||
|
assert plan.frame_symbol_count / lab045.SYMBOL_RATE == pytest.approx(0.2862)
|
||||||
|
assert (
|
||||||
|
plan.frame_symbol_count
|
||||||
|
+ 2 * lab045.GUARD_SYMBOL_COUNT
|
||||||
|
+ lab045.RRC_SPAN_SYMBOLS
|
||||||
|
) == 5766
|
||||||
|
|
||||||
|
|
||||||
|
def test_actual_lab044_waveform_builder_has_exact_length() -> None:
|
||||||
|
plan = lab045.build_transmission_plan(deterministic_payload())
|
||||||
|
tx_cs8 = lab045.build_tx_cs8(plan)
|
||||||
|
assert len(tx_cs8) == 2 * 2_306_400
|
||||||
|
assert np.max(np.abs(np.frombuffer(tx_cs8, dtype=np.int8).astype(np.int16))) < 127
|
||||||
|
|
||||||
|
|
||||||
|
def test_ideal_iq_adapter_reuses_lab044_sync_and_recovers_crc() -> None:
|
||||||
|
plan = lab045.build_transmission_plan(deterministic_payload())
|
||||||
|
waveform = lab044.signed_iq_bytes_to_complex64(lab045.build_tx_cs8(plan))
|
||||||
|
capture = np.concatenate(
|
||||||
|
(
|
||||||
|
np.zeros(50_000, dtype=np.complex64),
|
||||||
|
waveform,
|
||||||
|
np.zeros(50_000, dtype=np.complex64),
|
||||||
|
)
|
||||||
|
)
|
||||||
|
reception = lab045.analyze_capture_independently(capture)
|
||||||
|
assert reception.analysis["phy_sync_pass"] is True
|
||||||
|
assert reception.analysis["crc"] == lab045.CRC_PASS
|
||||||
|
assert reception.payload_bytes == plan.payload
|
||||||
|
|
||||||
|
|
||||||
|
def test_distributed_errors_are_corrected_and_prove_fec() -> None:
|
||||||
|
plan = lab045.build_transmission_plan(deterministic_payload())
|
||||||
|
soft = lab045.simulate_soft_channel(plan, bit_error_probability=0.006, seed=7)
|
||||||
|
reception = lab045.analyze_post_preamble_soft(soft)
|
||||||
|
diagnostic = lab045.diagnostic_pre_and_post_fec(reception, soft, plan)
|
||||||
|
assert diagnostic["pre_fec_coded"]["bit_errors"] > 0 # raw channel has errors
|
||||||
|
assert reception.analysis["crc"] == lab045.CRC_PASS
|
||||||
|
assert diagnostic["post_fec_payload"]["bit_perfect"] is True # FEC fixed them
|
||||||
|
|
||||||
|
|
||||||
|
def test_short_burst_survives_interleaver() -> None:
|
||||||
|
plan = lab045.build_transmission_plan(deterministic_payload())
|
||||||
|
burst = tuple(range(lab045.PHY_HEADER_BIT_COUNT + 500, lab045.PHY_HEADER_BIT_COUNT + 500 + 14))
|
||||||
|
soft = lab045.simulate_soft_channel(plan, burst_positions=burst)
|
||||||
|
reception = lab045.analyze_post_preamble_soft(soft)
|
||||||
|
assert reception.analysis["crc"] == lab045.CRC_PASS
|
||||||
|
assert reception.payload_bytes == plan.payload
|
||||||
|
|
||||||
|
|
||||||
|
def test_soft_ambiguous_symbols_near_zero_are_handled() -> None:
|
||||||
|
plan = lab045.build_transmission_plan(deterministic_payload())
|
||||||
|
soft = lab045.simulate_soft_channel(plan)
|
||||||
|
generator = np.random.default_rng(3)
|
||||||
|
weak = generator.choice(len(soft), 40, replace=False)
|
||||||
|
soft[weak] = 1e-6 * np.sign(soft[weak] + 1e-9) # near-zero magnitude, defined behavior
|
||||||
|
reception = lab045.analyze_post_preamble_soft(soft)
|
||||||
|
assert reception.analysis["crc"] == lab045.CRC_PASS
|
||||||
|
|
||||||
|
|
||||||
|
def test_exact_zero_soft_values_are_deterministic() -> None:
|
||||||
|
plan = lab045.build_transmission_plan(deterministic_payload())
|
||||||
|
soft = lab045.simulate_soft_channel(plan)
|
||||||
|
soft[lab045.PHY_HEADER_BIT_COUNT + 100 : lab045.PHY_HEADER_BIT_COUNT + 106] = 0.0
|
||||||
|
first = lab045.analyze_post_preamble_soft(soft)
|
||||||
|
second = lab045.analyze_post_preamble_soft(soft.copy())
|
||||||
|
assert first.analysis == second.analysis
|
||||||
|
assert first.packet_bytes == second.packet_bytes
|
||||||
|
|
||||||
|
|
||||||
|
def test_extra_trailing_soft_is_ignored_deterministically() -> None:
|
||||||
|
plan = lab045.build_transmission_plan(deterministic_payload())
|
||||||
|
soft = lab045.simulate_soft_channel(plan)
|
||||||
|
padded = np.concatenate((soft, np.zeros(1000, dtype=np.float64)))
|
||||||
|
reception = lab045.analyze_post_preamble_soft(padded)
|
||||||
|
assert reception.analysis["crc"] == lab045.CRC_PASS
|
||||||
|
assert reception.payload_bytes == plan.payload
|
||||||
|
|
||||||
|
|
||||||
|
def test_truncated_coded_frame_fails_closed() -> None:
|
||||||
|
plan = lab045.build_transmission_plan(deterministic_payload())
|
||||||
|
soft = lab045.simulate_soft_channel(plan)
|
||||||
|
truncated = soft[: lab045.PHY_HEADER_BIT_COUNT + 200]
|
||||||
|
reception = lab045.analyze_post_preamble_soft(truncated)
|
||||||
|
assert reception.analysis["phy_header_pass"] is True
|
||||||
|
assert reception.analysis["packet_recovered"] is False
|
||||||
|
assert reception.analysis["crc"] == lab045.CRC_NOT_REACHED
|
||||||
|
assert reception.packet_bytes is None
|
||||||
|
|
||||||
|
|
||||||
|
def test_crc_corruption_after_valid_fec_decode_is_crc_fail() -> None:
|
||||||
|
payload = deterministic_payload()
|
||||||
|
packet = bytearray(build_packet(payload, lab045.MESSAGE_TYPE, lab045.SEQUENCE_NUMBER))
|
||||||
|
# Меняется payload bit; sync/version/length остаются верны, CRC расходится.
|
||||||
|
packet[HEADER_SIZE + 5] ^= 0x01
|
||||||
|
information_bits = lab044.bytes_to_bits(bytes(packet))
|
||||||
|
coded = conv.encode(information_bits)
|
||||||
|
permutation = interleaver.build_permutation(len(coded), lab045.INTERLEAVER_COLUMNS)
|
||||||
|
interleaved = interleaver.interleave(coded, permutation)
|
||||||
|
header = lab045.encode_phy_header(len(packet))
|
||||||
|
soft = lab045.modulate_bits_to_ideal_soft(np.concatenate((header, interleaved)))
|
||||||
|
reception = lab045.analyze_post_preamble_soft(soft)
|
||||||
|
assert reception.analysis["crc"] == lab045.CRC_FAIL
|
||||||
|
assert reception.analysis["classification"] == "B"
|
||||||
|
assert reception.payload_bytes is None
|
||||||
|
|
||||||
|
|
||||||
|
# ---- Защищённый PHY header ---------------------------------------------------
|
||||||
|
|
||||||
|
|
||||||
|
def _header_soft(packet_length: int) -> np.ndarray:
|
||||||
|
return lab045.modulate_bits_to_ideal_soft(lab045.encode_phy_header(packet_length))
|
||||||
|
|
||||||
|
|
||||||
|
def test_header_majority_survives_one_error_per_repetition_group() -> None:
|
||||||
|
soft = _header_soft(268)
|
||||||
|
# В каждой побитовой тройке b,b,b повреждена ровно одна копия.
|
||||||
|
soft[0::lab045.HEADER_REPETITION] *= -1.0
|
||||||
|
header = lab045.decode_phy_header_soft(soft)
|
||||||
|
assert header["passed"] is True
|
||||||
|
assert header["packet_bytes"] == 268
|
||||||
|
|
||||||
|
|
||||||
|
def test_header_two_errors_in_one_group_are_caught_by_checksum() -> None:
|
||||||
|
soft = _header_soft(268)
|
||||||
|
# Две из трёх копий одного бита повреждены: majority меняет этот бит.
|
||||||
|
target = 32 # бит внутри поля длины
|
||||||
|
group_start = target * lab045.HEADER_REPETITION
|
||||||
|
soft[group_start] = -soft[group_start]
|
||||||
|
soft[group_start + 1] = -soft[group_start + 1]
|
||||||
|
header = lab045.decode_phy_header_soft(soft)
|
||||||
|
assert header["passed"] is False
|
||||||
|
assert header["reason"] in {"CHECKSUM_MISMATCH", "LENGTH_OUT_OF_RANGE", "MAGIC_MISMATCH"}
|
||||||
|
|
||||||
|
|
||||||
|
def test_header_bad_magic_fails_closed() -> None:
|
||||||
|
fields = struct.pack(lab045.PHY_HEADER_FIELDS_FORMAT, 0x1234, lab045.PHY_HEADER_VERSION, 268,
|
||||||
|
lab045._phy_header_checksum(0x1234, lab045.PHY_HEADER_VERSION, 268))
|
||||||
|
bits = np.repeat(lab044.bytes_to_bits(fields), lab045.HEADER_REPETITION)
|
||||||
|
header = lab045.decode_phy_header_soft(lab045.modulate_bits_to_ideal_soft(bits))
|
||||||
|
assert header["passed"] is False
|
||||||
|
assert header["reason"] == "MAGIC_MISMATCH"
|
||||||
|
|
||||||
|
|
||||||
|
def test_header_impossible_length_fails_closed() -> None:
|
||||||
|
bad_length = lab045.MAX_PACKET_BYTES + 500
|
||||||
|
fields = struct.pack(lab045.PHY_HEADER_FIELDS_FORMAT, lab045.PHY_MAGIC, lab045.PHY_HEADER_VERSION,
|
||||||
|
bad_length, lab045._phy_header_checksum(lab045.PHY_MAGIC, lab045.PHY_HEADER_VERSION, bad_length))
|
||||||
|
bits = np.repeat(lab044.bytes_to_bits(fields), lab045.HEADER_REPETITION)
|
||||||
|
header = lab045.decode_phy_header_soft(lab045.modulate_bits_to_ideal_soft(bits))
|
||||||
|
assert header["passed"] is False
|
||||||
|
assert header["reason"] == "LENGTH_OUT_OF_RANGE"
|
||||||
|
|
||||||
|
|
||||||
|
def test_header_truncated_fails_closed() -> None:
|
||||||
|
header = lab045.decode_phy_header_soft(np.zeros(10, dtype=np.float64))
|
||||||
|
assert header["passed"] is False
|
||||||
|
assert header["reason"] == "TRUNCATED"
|
||||||
|
|
||||||
|
|
||||||
|
def test_header_too_short_protocol_length_fails_closed() -> None:
|
||||||
|
short_length = lab045.MIN_PACKET_BYTES - 1
|
||||||
|
fields = struct.pack(
|
||||||
|
lab045.PHY_HEADER_FIELDS_FORMAT,
|
||||||
|
lab045.PHY_MAGIC,
|
||||||
|
lab045.PHY_HEADER_VERSION,
|
||||||
|
short_length,
|
||||||
|
lab045._phy_header_checksum(
|
||||||
|
lab045.PHY_MAGIC,
|
||||||
|
lab045.PHY_HEADER_VERSION,
|
||||||
|
short_length,
|
||||||
|
),
|
||||||
|
)
|
||||||
|
bits = np.repeat(lab044.bytes_to_bits(fields), lab045.HEADER_REPETITION)
|
||||||
|
header = lab045.decode_phy_header_soft(lab045.modulate_bits_to_ideal_soft(bits))
|
||||||
|
assert header["passed"] is False
|
||||||
|
assert header["reason"] == "LENGTH_OUT_OF_RANGE"
|
||||||
|
with pytest.raises(ValueError):
|
||||||
|
lab045.encode_phy_header(short_length)
|
||||||
|
|
||||||
|
|
||||||
|
def test_header_unknown_version_fails_closed() -> None:
|
||||||
|
version = lab045.PHY_HEADER_VERSION + 1
|
||||||
|
fields = struct.pack(
|
||||||
|
lab045.PHY_HEADER_FIELDS_FORMAT,
|
||||||
|
lab045.PHY_MAGIC,
|
||||||
|
version,
|
||||||
|
268,
|
||||||
|
lab045._phy_header_checksum(lab045.PHY_MAGIC, version, 268),
|
||||||
|
)
|
||||||
|
bits = np.repeat(lab044.bytes_to_bits(fields), lab045.HEADER_REPETITION)
|
||||||
|
header = lab045.decode_phy_header_soft(lab045.modulate_bits_to_ideal_soft(bits))
|
||||||
|
assert header["passed"] is False
|
||||||
|
assert header["reason"] == "VERSION_MISMATCH"
|
||||||
|
|
||||||
|
|
||||||
|
# ---- Детерминизм и отсутствие утечки TX data --------------------------------
|
||||||
|
|
||||||
|
|
||||||
|
def test_frame_build_is_deterministic() -> None:
|
||||||
|
payload = deterministic_payload()
|
||||||
|
first = lab045.build_transmission_plan(payload)
|
||||||
|
second = lab045.build_transmission_plan(payload)
|
||||||
|
assert np.array_equal(first.coded_bits, second.coded_bits)
|
||||||
|
assert np.array_equal(first.interleaved_bits, second.interleaved_bits)
|
||||||
|
assert np.array_equal(first.frame_bits, second.frame_bits)
|
||||||
|
|
||||||
|
|
||||||
|
def test_analyzer_does_not_receive_tx_payload() -> None:
|
||||||
|
# Независимый analyzer принимает только soft values. TX data поступают
|
||||||
|
# лишь в отдельную диагностику ПОСЛЕ CRC-решения.
|
||||||
|
import inspect
|
||||||
|
|
||||||
|
analyze_parameters = list(inspect.signature(lab045.analyze_post_preamble_soft).parameters)
|
||||||
|
assert analyze_parameters == ["post_preamble_soft"]
|
||||||
|
capture_parameters = list(inspect.signature(lab045.analyze_capture_independently).parameters)
|
||||||
|
assert capture_parameters == ["samples"]
|
||||||
|
diagnostic_parameters = list(inspect.signature(lab045.diagnostic_pre_and_post_fec).parameters)
|
||||||
|
assert "plan" in diagnostic_parameters # TX reference only here
|
||||||
|
|
||||||
|
|
||||||
|
def test_no_leakage_order_independent_then_diagnostic() -> None:
|
||||||
|
events: list[str] = []
|
||||||
|
plan = lab045.build_transmission_plan(deterministic_payload())
|
||||||
|
soft = lab045.simulate_soft_channel(plan, bit_error_probability=0.006, seed=5)
|
||||||
|
|
||||||
|
events.append("independent_decode")
|
||||||
|
reception = lab045.analyze_post_preamble_soft(soft)
|
||||||
|
assert reception.analysis["crc"] in {lab045.CRC_PASS, lab045.CRC_FAIL, lab045.CRC_NOT_REACHED}
|
||||||
|
|
||||||
|
events.append("diagnostic_read")
|
||||||
|
diagnostic = lab045.diagnostic_pre_and_post_fec(reception, soft, plan)
|
||||||
|
assert diagnostic["receiver_knew_payload_before_decode"] is False
|
||||||
|
assert events == ["independent_decode", "diagnostic_read"]
|
||||||
|
|
||||||
|
|
||||||
|
# ---- Научная проверка soft против hard decision ------------------------------
|
||||||
|
|
||||||
|
|
||||||
|
def test_soft_decision_beats_hard_on_a_real_noisy_case() -> None:
|
||||||
|
"""Детерминированный AWGN-случай, где амплитуды дают реальную пользу."""
|
||||||
|
|
||||||
|
information = np.random.default_rng(123).integers(0, 2, 128, dtype=np.uint8)
|
||||||
|
coded = conv.encode(information)
|
||||||
|
permutation = interleaver.build_permutation(len(coded), 32)
|
||||||
|
interleaved_bits = interleaver.interleave(coded, permutation)
|
||||||
|
soft = (
|
||||||
|
lab045.modulate_bits_to_ideal_soft(interleaved_bits)
|
||||||
|
+ np.random.default_rng(0).normal(0.0, 0.7, size=len(interleaved_bits))
|
||||||
|
)
|
||||||
|
|
||||||
|
soft_decoded = conv.viterbi_decode_soft(
|
||||||
|
interleaver.deinterleave(soft, permutation),
|
||||||
|
len(information),
|
||||||
|
)
|
||||||
|
hard_decoded = conv.viterbi_decode_hard(
|
||||||
|
interleaver.deinterleave((soft >= 0.0).astype(np.uint8), permutation),
|
||||||
|
len(information),
|
||||||
|
)
|
||||||
|
|
||||||
|
assert np.array_equal(soft_decoded, information)
|
||||||
|
assert not np.array_equal(hard_decoded, information)
|
||||||
|
|
||||||
|
|
||||||
|
def test_full_chain_with_deterministic_gaussian_noise_passes_crc() -> None:
|
||||||
|
plan = lab045.build_transmission_plan(deterministic_payload())
|
||||||
|
soft = lab045.simulate_soft_channel(plan, noise_sigma=0.45, seed=45)
|
||||||
|
reception = lab045.analyze_post_preamble_soft(soft)
|
||||||
|
assert reception.analysis["crc"] == lab045.CRC_PASS
|
||||||
|
assert reception.payload_bytes == plan.payload
|
||||||
|
|
||||||
|
|
||||||
|
def test_direct_invocation_smoke() -> None:
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
from pathlib import Path
|
||||||
|
|
||||||
|
project_root = Path(__file__).resolve().parents[1]
|
||||||
|
result = subprocess.run(
|
||||||
|
[sys.executable, str(project_root / "experiments" / "lab045_hackrf_bpsk_fec.py")],
|
||||||
|
cwd=project_root,
|
||||||
|
capture_output=True,
|
||||||
|
text=True,
|
||||||
|
timeout=60,
|
||||||
|
)
|
||||||
|
assert result.returncode == 0, result.stderr
|
||||||
|
assert "total symbols = 5724" in result.stdout
|
||||||
|
assert "waveform samples = 2306400" in result.stdout
|
||||||
|
assert "synthetic CRC = PASS" in result.stdout
|
||||||
|
|
||||||
|
|
||||||
|
def test_hardware_entry_point_is_fail_closed() -> None:
|
||||||
|
import subprocess
|
||||||
|
import sys
|
||||||
|
from pathlib import Path
|
||||||
|
|
||||||
|
project_root = Path(__file__).resolve().parents[1]
|
||||||
|
result = subprocess.run(
|
||||||
|
[
|
||||||
|
sys.executable,
|
||||||
|
str(project_root / "experiments" / "lab045_hackrf_bpsk_fec.py"),
|
||||||
|
"--hardware",
|
||||||
|
],
|
||||||
|
cwd=project_root,
|
||||||
|
capture_output=True,
|
||||||
|
text=True,
|
||||||
|
timeout=60,
|
||||||
|
)
|
||||||
|
assert result.returncode == 2
|
||||||
|
assert "RF TX = 0" in result.stdout
|
||||||
|
|
||||||
|
|
||||||
|
# ---- Fail-closed аппаратная обвязка без реального RF -------------------------
|
||||||
|
|
||||||
|
|
||||||
|
class HardwareFakeRunner:
|
||||||
|
def __init__(self) -> None:
|
||||||
|
self.commands: list[list[str]] = []
|
||||||
|
|
||||||
|
def __call__(self, command: list[str]):
|
||||||
|
import subprocess
|
||||||
|
|
||||||
|
self.commands.append(command)
|
||||||
|
if command[0].lower().endswith("hackrf_info.exe"):
|
||||||
|
output = (
|
||||||
|
f"Serial number: {lab044.lab043.MASTER_SERIAL}\n"
|
||||||
|
f"Serial number: {lab044.lab043.SLAVE_SERIAL}\n"
|
||||||
|
)
|
||||||
|
elif "-t" in command:
|
||||||
|
output = "0 underruns\n"
|
||||||
|
else:
|
||||||
|
output = ""
|
||||||
|
return subprocess.CompletedProcess(command, 0, output, "")
|
||||||
|
|
||||||
|
|
||||||
|
class HardwareFakeProcess:
|
||||||
|
def __init__(self, startup_failed: bool = False) -> None:
|
||||||
|
self.startup_failed = startup_failed
|
||||||
|
self.terminated = False
|
||||||
|
|
||||||
|
def poll(self) -> int | None:
|
||||||
|
return 1 if self.startup_failed else (0 if self.terminated else None)
|
||||||
|
|
||||||
|
def wait(self, timeout: float) -> int:
|
||||||
|
del timeout
|
||||||
|
return 0
|
||||||
|
|
||||||
|
def terminate(self) -> None:
|
||||||
|
self.terminated = True
|
||||||
|
|
||||||
|
def close_logs(self) -> None:
|
||||||
|
pass
|
||||||
|
|
||||||
|
|
||||||
|
class HardwareFakeStarter:
|
||||||
|
def __init__(self, startup_failed: bool = False) -> None:
|
||||||
|
self.startup_failed = startup_failed
|
||||||
|
self.processes: list[HardwareFakeProcess] = []
|
||||||
|
|
||||||
|
def __call__(self, command: list[str], stdout_path, stderr_path):
|
||||||
|
from pathlib import Path
|
||||||
|
|
||||||
|
stdout_path.write_text("0 overruns\n", encoding="utf-8")
|
||||||
|
stderr_path.write_text("", encoding="utf-8")
|
||||||
|
raw_path = Path(command[command.index("-r") + 1])
|
||||||
|
raw_path.write_bytes(bytes(2 * lab045.CAPTURE_SAMPLE_COUNT))
|
||||||
|
process = HardwareFakeProcess(self.startup_failed)
|
||||||
|
self.processes.append(process)
|
||||||
|
return process
|
||||||
|
|
||||||
|
|
||||||
|
def allow_hardware_preflight(runner, guard) -> dict:
|
||||||
|
del runner
|
||||||
|
guard.allow()
|
||||||
|
return {
|
||||||
|
"passed": True,
|
||||||
|
"master_reg29": 0x26,
|
||||||
|
"slave_reg29": 0x26,
|
||||||
|
"slave_clkin_status": "DETECTED",
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def prepare_small_hardware_mock(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||||
|
monkeypatch.setattr(lab045, "CAPTURE_SAMPLE_COUNT", 16)
|
||||||
|
monkeypatch.setattr(lab045, "SAMPLES_PER_SYMBOL", 1)
|
||||||
|
monkeypatch.setattr(lab045, "GUARD_SYMBOL_COUNT", 0)
|
||||||
|
monkeypatch.setattr(lab045, "RRC_SPAN_SYMBOLS", 0)
|
||||||
|
monkeypatch.setattr(
|
||||||
|
lab045,
|
||||||
|
"build_tx_cs8",
|
||||||
|
lambda plan: bytes(2 * plan.waveform_sample_count),
|
||||||
|
)
|
||||||
|
monkeypatch.setattr(
|
||||||
|
lab044.lab043,
|
||||||
|
"common_clock_preflight",
|
||||||
|
allow_hardware_preflight,
|
||||||
|
)
|
||||||
|
monkeypatch.setattr(lab044.lab043, "_disable_clock_outputs", lambda runner: [])
|
||||||
|
|
||||||
|
|
||||||
|
def test_hardware_common_clock_failure_means_zero_tx(
|
||||||
|
tmp_path, monkeypatch: pytest.MonkeyPatch
|
||||||
|
) -> None:
|
||||||
|
prepare_small_hardware_mock(monkeypatch)
|
||||||
|
runner = HardwareFakeRunner()
|
||||||
|
monkeypatch.setattr(
|
||||||
|
lab044.lab043,
|
||||||
|
"common_clock_preflight",
|
||||||
|
lambda runner, guard: (_ for _ in ()).throw(RuntimeError("clock")),
|
||||||
|
)
|
||||||
|
with pytest.raises(RuntimeError, match="clock"):
|
||||||
|
lab045.run_hardware_experiment(
|
||||||
|
tmp_path,
|
||||||
|
runner=runner,
|
||||||
|
payload_factory=lambda count: bytes(count),
|
||||||
|
process_checker=lambda: [],
|
||||||
|
)
|
||||||
|
assert not any("-t" in command for command in runner.commands)
|
||||||
|
assert (tmp_path / "failure.json").is_file()
|
||||||
|
|
||||||
|
|
||||||
|
def test_hardware_rx_startup_failure_means_zero_tx(
|
||||||
|
tmp_path, monkeypatch: pytest.MonkeyPatch
|
||||||
|
) -> None:
|
||||||
|
prepare_small_hardware_mock(monkeypatch)
|
||||||
|
runner = HardwareFakeRunner()
|
||||||
|
starter = HardwareFakeStarter(startup_failed=True)
|
||||||
|
with pytest.raises(RuntimeError, match="RX завершился"):
|
||||||
|
lab045.run_hardware_experiment(
|
||||||
|
tmp_path,
|
||||||
|
runner=runner,
|
||||||
|
process_starter=starter,
|
||||||
|
sleep_function=lambda seconds: None,
|
||||||
|
payload_factory=lambda count: bytes(count),
|
||||||
|
process_checker=lambda: [],
|
||||||
|
)
|
||||||
|
assert not any("-t" in command for command in runner.commands)
|
||||||
|
assert starter.processes[0].terminated is True
|
||||||
|
|
||||||
|
|
||||||
|
def test_hardware_one_tx_cleanup_and_artifacts(
|
||||||
|
tmp_path, monkeypatch: pytest.MonkeyPatch
|
||||||
|
) -> None:
|
||||||
|
import hashlib
|
||||||
|
import json
|
||||||
|
|
||||||
|
prepare_small_hardware_mock(monkeypatch)
|
||||||
|
runner = HardwareFakeRunner()
|
||||||
|
starter = HardwareFakeStarter()
|
||||||
|
payload = deterministic_payload()
|
||||||
|
packet = build_packet(payload, lab045.MESSAGE_TYPE, lab045.SEQUENCE_NUMBER)
|
||||||
|
reception = lab045.IndependentReception(
|
||||||
|
{
|
||||||
|
"classification": "A",
|
||||||
|
"crc": lab045.CRC_PASS,
|
||||||
|
"phy_sync_pass": True,
|
||||||
|
"phy_header_pass": True,
|
||||||
|
"fec_decode_pass": True,
|
||||||
|
"protocol_header_pass": True,
|
||||||
|
},
|
||||||
|
packet,
|
||||||
|
payload,
|
||||||
|
)
|
||||||
|
events: list[str] = []
|
||||||
|
|
||||||
|
def analyzer(samples: np.ndarray) -> lab045.IndependentReception:
|
||||||
|
del samples
|
||||||
|
events.append("independent_decode")
|
||||||
|
return reception
|
||||||
|
|
||||||
|
def comparer(result, samples, tx_payload_path, tx_packet_path) -> dict:
|
||||||
|
del result, samples
|
||||||
|
assert events == ["independent_decode"]
|
||||||
|
assert tx_payload_path.read_bytes() == payload
|
||||||
|
assert tx_packet_path.read_bytes() == packet
|
||||||
|
events.append("diagnostic_read")
|
||||||
|
return {
|
||||||
|
"stage": "AFTER_INDEPENDENT_CRC_DECISION",
|
||||||
|
"receiver_knew_payload_before_decode": False,
|
||||||
|
"pre_fec_coded": {"bit_errors": 3, "ber": 3 / 4300},
|
||||||
|
"post_fec_packet": {"bit_errors": 0, "ber": 0.0},
|
||||||
|
"post_fec_payload": {
|
||||||
|
"bit_errors": 0,
|
||||||
|
"byte_errors": 0,
|
||||||
|
"bit_perfect": True,
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
result = lab045.run_hardware_experiment(
|
||||||
|
tmp_path,
|
||||||
|
runner=runner,
|
||||||
|
process_starter=starter,
|
||||||
|
sleep_function=lambda seconds: None,
|
||||||
|
payload_factory=lambda count: payload,
|
||||||
|
analyzer=analyzer,
|
||||||
|
comparer=comparer,
|
||||||
|
process_checker=lambda: [],
|
||||||
|
)
|
||||||
|
assert result["classification"] == "A"
|
||||||
|
assert result["analysis"]["real_rf_fec_correction_demonstrated"] is True
|
||||||
|
assert sum("-t" in command for command in runner.commands) == 1
|
||||||
|
assert events == ["independent_decode", "diagnostic_read"]
|
||||||
|
assert starter.processes[0].terminated is True
|
||||||
|
metadata = json.loads((tmp_path / "metadata.json").read_text(encoding="utf-8"))
|
||||||
|
assert metadata["rf_tx_count"] == 1
|
||||||
|
assert metadata["cleanup"]["clock_outputs_off"] is True
|
||||||
|
assert metadata["cleanup"]["no_lingering_hackrf_transfer"] is True
|
||||||
|
assert metadata["artifact_sha256_verified"] is True
|
||||||
|
for name, digest in metadata["artifact_sha256"].items():
|
||||||
|
path = tmp_path / name
|
||||||
|
if path.is_file():
|
||||||
|
assert digest == hashlib.sha256(path.read_bytes()).hexdigest()
|
||||||
Reference in New Issue
Block a user