В предыдущей части статьи были рассмотрены принципы и механизмы работы PHY-уровня радиолюбительского OFDM-протокола, а также алгоритмы кодирования и декодирования данных. В этой статье рассматриваются принципы построения уровней управления доступом к среде (MAC) и управления логическим каналом (LLC), реализующих соединение между двумя трансиверами, а также анализируются возникшие при реализации и методы их решения.

Введение

Рассмотренный в рамках прошлой статьи OFDM-модем обеспечил возможность передачи произвольных данных, выполняя функции PHY-уровень. Для организации устойчивого обмена информацией между узлами сети требуется внедрение дополнительных уровней абстракции, обеспечивающих установление сессии, создание прямого канала передачи данных, мониторинг состояния соединения и контроль целостности доставки пакетов.

В соответствии с моделью OSI канальный уровень подразделяется на MAC и LLC подуровни. Подуровень MAC (Medium Access Control) отвечает за формирование пакетов и контроль коллизий в среде передачи. Функциями LLC (Logical Link Control) являются управление информационным потоком, контроль целостности принятых данных, их квитирование (подтверждение) и инициация повторной передачи искаженных пакетов.

Реализация указанных подуровней преобразует разрабатываемый OFDM-протокол из средства однонаправленной передачи данных (наподобие телеграфа) в полнодуплексную систему связи.

TL;DR

Большая часть статьи посвящена описанию алгоритмов конечных автоматов (FSM) и сопутствующих структурах данных. Радиолюбительская часть начинается в разделе "Тестирование.

Под спойлером краткое изложение статьи в формате вопрос-ответ:

Изменения на PHY-уровне

Параллельно с проектированием MAC и LLC-уровней, модернизации подвергся физический (PHY) уровень. Был интегрирован метод модуляции 16-QAM, обеспечивающий кодирование 4 бит на один поднесущий символ. Также было изменено количество поднесущих в одном символе, интервал частот составляет 46.875 Гц. Формируемый OFDM-символ использует сетку из 53 ортогональных поднесущих.

PSK-созвездия

На рисунках 1, 2, 3 приведены примеры сигнальных созвездий и соответствующее им кодирование бит.

Таблица кодирования BPSK:

_MAPPING_TABLE = {
    (0,): -1 + 0j,
    (1,): 1 + 0j,
}

Таблица кодирования QPSK:

_NORM = np.sqrt(2.0)
_MAPPING_TABLE = {
    (0, 0): (-1.0 - 1j) / _NORM,
    (0, 1): (-1.0 + 1j) / _NORM,
    (1, 1): (1.0 + 1j) / _NORM,
    (1, 0): (1.0 - 1j) / _NORM,
}

Таблица кодирования 16-QAM:

_NORM = np.sqrt(10.0)
_MAPPING_TABLE = {
    (0, 0, 0, 0): (-3.0 - 3j) / _NORM,
    (0, 0, 0, 1): (-3.0 - 1j) / _NORM,
    (0, 0, 1, 1): (-3.0 + 1j) / _NORM,
    (0, 0, 1, 0): (-3.0 + 3j) / _NORM,
    (0, 1, 0, 0): (-1.0 - 3j) / _NORM,
    (0, 1, 0, 1): (-1.0 - 1j) / _NORM,
    (0, 1, 1, 1): (-1.0 + 1j) / _NORM,
    (0, 1, 1, 0): (-1.0 + 3j) / _NORM,
    (1, 1, 0, 0): (1.0 - 3j) / _NORM,
    (1, 1, 0, 1): (1.0 - 1j) / _NORM,
    (1, 1, 1, 1): (1.0 + 1j) / _NORM,
    (1, 1, 1, 0): (1.0 + 3j) / _NORM,
    (1, 0, 0, 0): (3.0 - 3j) / _NORM,
    (1, 0, 0, 1): (3.0 - 1j) / _NORM,
    (1, 0, 1, 1): (3.0 + 1j) / _NORM,
    (1, 0, 1, 0): (3.0 + 3j) / _NORM,
}

Метод квадратурной амплитудной модуляции 16-QAM характеризуется более плотным созвездием, позволяющий передавать по 4 бита в одном сигнальном символе. Для минимизации вероятности возникновения битовых ошибок в условиях замираний и шумов при маппинге применяется код Грея.

Также, в протокол внедрена модуляция 32-QAM, обеспечивающая перенос до 5 бит информации в сигнальном симовле.

Таблица кодирования 16-QAM:

_NORM = np.sqrt(20.0)
_MAPPING_TABLE = {
    (0, 0, 0, 0, 0): (-3.0 - 5j) / _NORM, (0, 0, 0, 0, 1): (-3.0 - 3j) / _NORM,
    (0, 0, 0, 1, 1): (-3.0 - 1j) / _NORM, (0, 0, 0, 1, 0): (-3.0 + 1j) / _NORM,
    (0, 0, 1, 1, 0): (-3.0 + 3j) / _NORM, (0, 0, 1, 1, 1): (-3.0 + 5j) / _NORM,
    (0, 1, 0, 0, 0): (-1.0 - 5j) / _NORM, (0, 1, 0, 0, 1): (-1.0 - 3j) / _NORM,
    (0, 1, 0, 1, 1): (-1.0 - 1j) / _NORM, (0, 1, 0, 1, 0): (-1.0 + 1j) / _NORM,
    (0, 1, 1, 1, 0): (-1.0 + 3j) / _NORM, (0, 1, 1, 1, 1): (-1.0 + 5j) / _NORM,
    (1, 1, 0, 0, 0): (1.0 - 5j) / _NORM, (1, 1, 0, 0, 1): (1.0 - 3j) / _NORM,
    (1, 1, 0, 1, 1): (1.0 - 1j) / _NORM, (1, 1, 0, 1, 0): (1.0 + 1j) / _NORM,
    (1, 1, 1, 1, 0): (1.0 + 3j) / _NORM, (1, 1, 1, 1, 1): (1.0 + 5j) / _NORM,
    (1, 0, 0, 0, 0): (3.0 - 5j) / _NORM, (1, 0, 0, 0, 1): (3.0 - 3j) / _NORM,
    (1, 0, 0, 1, 1): (3.0 - 1j) / _NORM, (1, 0, 0, 1, 0): (3.0 + 1j) / _NORM,
    (1, 0, 1, 1, 0): (3.0 + 3j) / _NORM, (1, 0, 1, 1, 1): (3.0 + 5j) / _NORM,
    (0, 0, 1, 0, 0): (-5.0 - 3j) / _NORM, (0, 0, 1, 0, 1): (-5.0 - 1j) / _NORM,
    (0, 1, 1, 0, 1): (-5.0 + 1j) / _NORM, (0, 1, 1, 0, 0): (-5.0 + 3j) / _NORM,
    (1, 0, 1, 0, 0): (5.0 - 3j) / _NORM, (1, 0, 1, 0, 1): (5.0 - 1j) / _NORM,
    (1, 1, 1, 0, 1): (5.0 + 1j) / _NORM, (1, 1, 1, 0, 0): (5.0 + 3j) / _NORM,
}

Примечание:
32-QAM модуляция была интегрирована к моменту окончания написания статьи. Так как она не была протестирована достаточным образом, на данный момент она имеет статус экспериментальный. Предшествующие испытания с данным типом модуляции не увенчались успехом из-за деградации созвездий (подробнее см. ниже). Тем не менее, первичные лабораторные тесты подтверждают принципиальную реализуемость данного метода.

По причине высокой чувствительности OFDM к временной синхронизации, критичной на уровне единичных семплов (смещение на 1 семпл индуцирует фазовый сдвиг, а погрешность в 3 семпла приводит к полной потере способности демодулятора декодировать сигнал), было принято решение оставить двухэтапную схему синхронизации, базирующейся на комбинации преамбул Ньюмана и Задова-Чу с последующим когерентным накоплением для обеспечения помехозащищенности.

В текущей версии перебор гипотез в широкой полосе частот осуществляется исключительно детектором преамбулы Ньюмана. Детектор ZC-преамбулы единоразово осуществляет точную оценку CFO в пределах своей локальной полосы частот и определяет точные временные границы начала OFDM-сигнала.

Примечание:

В прошлой версии этот технический долг приводил к тому, что процедура точной оценки CFO по ZC-преамбуле нивелировала результаты предварительного грубого расчета по преамбуле Ньюмана. Так, если оценка Ньюмана фиксировала сдвиг в 101.3 Гц, то алгоритм ZC ошибочно определял значение в -101.5 Гц, фактически компенсируя корректную поправку, что исключало возможность успешного декодирования пакета.

Данная проблема проявлялась в условиях, когда в звуковом тракте помимо частотного дрейфа присутствовали выраженные нелинейности и фазовые искажения сигнала.

coarse: 27.4511Hz fine: -0.0596Hz
coarse: 27.4387Hz fine: -0.1148Hz
coarse: 27.4294Hz fine: 0.0565Hz
coarse: 27.4118Hz fine: -0.0813Hz

Снижение пик-фактора

В предыдущей модификации протокола с целью снижения PAPR применялся метод клиппирования с фильтрации (CAF), задача которого сводится к ограничению высоких значений амплитуд с последующей фильтрацией возникающих внеполосных спектральных составляющих. Многократное применение данного алгоритма обеспечило дополнительное снижение PAPR формируемого сигнала, а также привело к уменьшению вероятности появления ложных оценок CFO.

class OFDMWavModem(OFDMIQModem):
    DEFAULT_SAMPLE_RATE = 12000
    CAF_COUNT = 3


    def mod_payload_signal(self, header_payload: npt.NDArray[np.uint8], packet_payload: npt.NDArray[np.uint8],
                           mode: ModType) -> npt.NDArray[np.float64]:
        assert self.CAF_COUNT >= 1


        signal_full = super().mod_payload_signal(header_payload, packet_payload, mode)


        for _ in range(self.CAF_COUNT):
            signal_full = clip_and_filter(
                signal_full,
                papr_cutoff_db=6.0, cutoff_freq_hz=3000,
                fs_hz=self.DEFAULT_SAMPLE_RATE)


        gain = 0.9
        signal = signal_full / np.max(np.abs(signal_full)) * gain
        return signal

Количество итераций CAF_COUNT=3 было установлено эмпирическим путем. При таком значении достигается оптимальное снижение PAPR при отсутствии критических нелинейных фазовых искажений сигнала.

class OFDMSoundModem(OFDMWavModem):
    def _get_mode_256(self) -> dict:
        return dict(
            mapper=BPSKMapper,
            sample_rate=self.DEFAULT_SAMPLE_RATE,
            fft_bins=256,
            freq_lo=300,
            freq_hi=2750,
            zc_preamble_root=31,
            zc_preamble_len=53,
            zc_preamble_count=4,
            zc_pilots_root=57,
            zc_pilots_count=11,
            cp_percent=0.25,
            sym_tile=4,
            max_cfo=8,
            detection_threshold=0.20,
        )


    def _get_mode_128(self) -> dict:
        return dict(
            mapper=BPSKMapper,
            sample_rate=self.DEFAULT_SAMPLE_RATE,
            fft_bins=128,
            freq_lo=300,
            freq_hi=2400,
            zc_preamble_root=17,
            zc_preamble_len=23,
            zc_preamble_count=4,
            zc_pilots_root=3,
            zc_pilots_count=7,
            cp_percent=0.25,
            sym_tile=4,
            max_cfo=4,
            detection_threshold=0.20,
        )


    _get_modem_params = _get_mode_256

Для формирования спектра из 53 поднесущих была задействована расширенная полоса частот, от 300 до 2750 Гц. Под передачу пилот-сигналы выделено 11 поднесущих. В связи с расширением спектра был пропорционально увеличен диапазон частотных гипотез при поиске преамбулы в сигнале (параметр max_cfo=8).

Заголовок пакета

Базовая структура заголовка не претерпела принципиальных изменений. Под поле len выделено 10 бит, что теоретически позволяет передавать пакеты длиной до 1023 бит.

Примечание:
Ввиду использования индексации с нулевого значения, максимальный размер блока не кратен степени двойки. Автор отдает себе отчет в том, что бессмысленно передавать пакеты нулевой длины, но арифметикой выравнивания и индексации все равно пренебрег.

Суммарный объем информационной емкости заголовка составляет 28 бит.

Реализация заголовка:

@bit_packet
@dataclass
class Header(PacketCRC8):
    ver: int = field(default=IntField(2, min_val=1))
    typ: PacketType = field(default=EnumField(PacketType, 4))
    mod: ModType = field(default=EnumField(ModType, 2))
    spd: CCSpeed = field(default=EnumField(CCSpeed, 2))
    len: int = field(default=IntField(10, min_val=1))

Структура ModType поля mod расширена для поддержки 16-QAM и 32-QAM.

class ModType(Enum):
    BPSK = 0
    QPSK = 1
    QAM16 = 2
    QAM32 = 3

Поле скорости кодирования spd оставлено без изменений.

class CCSpeed(Enum):
    R13 = 0  # 1/3 slow
    R12 = 1  # 1/2
    R23 = 2  # 2/3
    R34 = 3  # 3/4 fast

Аналогично предыдущей версии, для достижения максимальной помехоустойчивости передача заголовка осуществляется с применением BPSK модуляции и скоростью сверточного кодирования ⅓.

Пример структуры сформированного заголовка: Header(ver=1, typ=<PacketType.BEACON: 0>, mod=<ModType.BPSK: 0>, spd=<CCSpeed.R13: 0>, len=90)

Битовое представление: 01_0000_00_00_0001011010_[01111001].

Эквалайзер и фильтр Винера

В условиях высокого отношения сигнал/шум (SNR) процесс эквализации с применением фильтра Винера вызывал деградацию сигнального созвездия (рисунок 5), что при использовании модуляций высших порядков существенно повышает вероятность битовых ошибок (BER).

Данный эффект был вызван некорректной регуляризацией в алгоритме расчета матрицы весов Винера. При высоких значениях SNR значение дисперсии шума ограничивалось снизу на фиксированном уровне. В результате перерегулирования фильтр вносил избыточное сглаживание в неискаженный сигнал. Для устранения этого эффекта в алгоритм эквалайзера была добавлена предварительная оценка дисперсии амплитудно-частотной характеристики (АЧХ), получаемой после линейной интерполяции методом Zero Forcing. На основе этой оценки адаптивный фильтр Винера применяется динамически — исключительно для поднесущих с высокой степенью деградации сигнала (рисунок 7).

core_channel = H_abs_init[4:-4]
channel_ripple = np.max(core_channel) - np.min(core_channel)


if channel_ripple > 0.6:
    H_est = self._channel_estimate_wiener(pilots_ref, pilots, self._pilot_carriers, curr_noise_var)
    equalized_all = (demod_channel * np.conj(H_est)) / (np.abs(H_est) ** 2 + curr_noise_var)
    equalized_data_symbols = equalized_all[self._data_local_indices]
else:
    H_est = H_est_init
    equalized_data_symbols = data_init

Для вычисления оценки неравномерностей АЧХ анализируется центральный диапазон поднесущих. Это необходимо для компенсации спада АЧХ в переходных полосах звукового тракта, а также для исключения влияния эффекта утечки спектра на границах используемого частотного диапазона.

Пороговое значение 0.6 для параметра channel_ripple определяет критическую степень неравномерности АЧХ по поднесущим. При превышении этого порога затухание сигнала на отдельных поднесущих достигает уровня от -3 до -4 дБ. В этих условиях проявляется снижение эффективности эквалайзера Zero Forcing из-за эффекта усиления шума, что обуславливает необходимость применения адаптивного фильтра Винера.

Примечание:
Поскольку заголовок передается строго в BPSK модуляции, на диаграмме сигнального созвездия он отображается в виде двух аномальных точек, которые могут быть ошибочно интерпретированы как артефакты. Фактически, сигнальное созвездие всех частей пакета визуализируются как единый массив точек.

Декодирование пакетов

Входной сигнал непрерывно передается в кольцевой буфер, глубина памяти которого рассчитана на временной интервал в несколько секунд. Данные из кольцевого буфера анализируются декодером, функционирующего на основе детерминированного конечного автомата (рисунок 8).

Накопление и анализ принимаемого сигнала осуществляется в методе process, на вход которого подается комплексный дискретный сигнал, полученный со звуковой карты.

Примечание:
Необходимо напомнить, что комплексный сигнал формируется преобразованием Гильберта на основе вещественного дискретного сигнала, захватываемого из звуковой карты.

def process(self, signal: np.ndarray):
    if len(signal) > 0:
        self._append_buffer(signal)


    if self.decoder_state == DecoderState.DETECT:
        self._reset_curr_state()


        if offset := self.modem.find_preamble(self.decoder_buffer[self.decoder_buffer_ptr:]):
            est_time, est_cfo = offset


            self.curr_cfo = est_cfo


            self._preamble_found(self.curr_cfo, self.decoder_buffer_ptr + est_time)
            self.decoder_buffer_ptr += est_time
            self._set_decoding_mode(Header, ModType.BPSK, CCSpeed.R13, Header.PACKET_SIZE)
            self.decoder_state = DecoderState.COLLECT_HEADER
        else:
            return
...

В методе process кольцевой буфер (см. далее) производит последовательную буферизацию данных. В состоянии DETECT в накопленном массиве осуществляется поиск преамбулы. При достижении порога обнаружения, автомат генерирует событие preamblefound и переходит в состояние накопления заголовка пакета данных COLLECT_HEADER. Одновременно с этим декодер переводится в режим демодуляции BPSK со скоростью сверточного кодера ⅓, при этом указатель семпла кольцевого буфера перемещается к предполагаемой временной границе заголовка, следующему непосредственно после преамбулы.

...
    if self.decoder_state in (DecoderState.COLLECT_HEADER, DecoderState.COLLECT_BODY):
        if self.curr_samples_required is None:
            self.curr_samples_required = self.modem.get_packet_num_samples(
                self.curr_mod_type, self.curr_cc_speed, self.curr_packet_size
            )


        if len(self.decoder_buffer) - self.decoder_buffer_ptr >= self.curr_samples_required:
            if self.decoder_state == DecoderState.COLLECT_HEADER:
                self.decoder_state = DecoderState.DECODE_HEAD
            else:
                self.decoder_state = DecoderState.DECODE_BODY
        else:
            return
...

В состоянии COLLECT (COLLECT_HEADER, COLLECT_BODY) отслеживается накопленный объем данных в кольцевом буфере. 

Метод get_packet_num_samples вычисляет эквивалентное число семплов, необходимое для размещения OFDM-сигнала при заданных объемах информации, скорости кодирования и типе модуляции.

При достижении рассчитанного объема накопленных данных автомат переходит в состояние декодирования DECODE (DECODE_HEAD, DECODE_BODY).

...
    if self.decoder_state in (DecoderState.DECODE_HEAD, DecoderState.DECODE_BODY):
        if response := self.modem.demod(
                self.decoder_buffer[self.decoder_buffer_ptr:], self.curr_cfo,
                mod_type=self.curr_mod_type,
                cc_speed=self.curr_cc_speed,
                packet_size=self.curr_packet_size,
                decoder=self.curr_codec):
            self._demod_response(response)
            self.decoder_buffer_ptr += self.curr_samples_required


            packet = response.packet
            if self.decoder_state == DecoderState.DECODE_HEAD:
                self._set_decoding_mode(PACKET_CODECS[packet.typ], packet.mod, packet.spd, packet.len)
                self.decoder_state = DecoderState.COLLECT_BODY


            elif self.decoder_state == DecoderState.DECODE_BODY:
                self._set_decoding_mode(None, None, None, None)
                self.decoder_state = DecoderState.PROCESS_PACKET
            else:
                raise DecoderFSMInvalidState
...

В состоянии DECODE (DECODE_HEAD, DECODE_BODY) выполняется демодуляция накопленного блока данных. При успешном декодировании автомат сохраняет принятый блок пакета. Если был декодирован заголовок (DECODE_HEAD), автомат динамически изменяет параметры декодера в соответствии с актуальными значениями из packet, после чего инициализирует обработку следующего блока.

После декодирования всех частей пакета, автомат переходит в состояние его обработки PROCESS_PACKET.

...
            self.curr_EsN0_packet += response.EsN0_packet
            self.curr_EsN0_carriers += response.EsN0_carriers
            self.curr_sym_count += response.sym_count
            self.curr_bits_count += response.bits_count
            self.curr_bits_error += response.bits_error
            self.curr_samples_count += response.samples_count
            packet.parent = self.curr_packet  # Link parent packet
            self.curr_packet = packet
            self.curr_samples_required = None
...

На данном этапе производится обновление внутренних счетчиков и регистрация метрик декодера. Поскольку для функционирования подуровня LLC требуется доступ к заголовку пакета, к телу добавляется соответствующий указатель в поле parent.

...
        elif self.decoder_state == DecoderState.DECODE_HEAD:
            self.decoder_state = DecoderState.DECODE_HEAD_FAILED


        elif self.decoder_state == DecoderState.DECODE_BODY:
            self.decoder_state = DecoderState.DECODE_BODY_FAILED


        else:
            raise DecoderFSMInvalidState
...

В случае некорректной демодуляции инициируется переход в состояние ошибки.

...
    if self.decoder_state == DecoderState.DECODE_HEAD_FAILED:
        self._decode_failed(True, False)
        self.decoder_state = DecoderState.DETECT


    if self.decoder_state == DecoderState.DECODE_BODY_FAILED:
        self._decode_failed(False, True)
        self.decoder_state = DecoderState.DETECT
...

Так как состояние ошибки не является терминальным, возвращается в исходное состояние детекции преамбулы. Метод _decode_failed генерирует событие об ошибке.

...
    if self.decoder_state == DecoderState.PROCESS_PACKET:
        BER = self.curr_bits_error / self.curr_bits_count
        EsN0_carriers_dB = dB_vectorized(self.curr_EsN0_carriers / self.curr_sym_count)
        EsN0_packet_dB = dB(self.curr_EsN0_packet / self.curr_sym_count)
        SNR_packet_dB = EsN0_packet_dB - self.modem._snr_off


        samples = self.curr_samples_count
        speed = self.curr_bits_count * self.modem.DEFAULT_SAMPLE_RATE / samples


        self._process_packet(self.curr_packet, EsN0_carriers_dB, EsN0_packet_dB, SNR_packet_dB, BER, speed)


        self.decoder_state = DecoderState.DETECT

В состоянии PROCESS_PACKET осуществляется обновление счетчиков, расчет отношения энергии OFDM-символов к спектральной мощности шума, вычисление интегрального SNR и оценка битовой скорости соединения. Далее формируется  событие _process_packet и автомат возвращается в исходное состояние DETECT.

Алгоритм заполнения кольцевого буфера:

def _append_buffer(self, signal: np.ndarray) -> None:
    length = len(signal)
    self.decoder_buffer = np.roll(self.decoder_buffer, -length)
    self.decoder_buffer[-length:] = signal
    self.decoder_buffer_ptr = max(0, self.decoder_buffer_ptr - length)

Использование кольцевого буфера обусловлено необходимостью непрерывного размещения обрабатываемого фрагмента сигнала для корректной детекции преамбулы и демодуляции OFDM-данных. Данный подход упрощает реализацию и убирает необходимость вводить дополнительные состояния автоматов с прерываниями между уровнями абстракций.

MAC и LLC уровни

Процесс трансформации модема в полноценное средство связи осуществляется добавлением алгоритмов установления соединения и организации пакетной передачи данных с возможностью адаптации к динамическим параметрам канала связи.

Над PHY уровнем располагается логика подуровня MAC, функционирующая на основе модели конечного автомата, в задачи которого входит установка соединения между двумя узлами в канале, а также фильтрации входящего трафика.

Подуровень LLC реализует функции логической сессии, развертываемой в рамках установленного соединения. FSM сессии обеспечивает строгое соблюдение регламента протокола, координируя временное разделение приема и передачи, формируя входящие и исходящие очереди данных, а также инкапсулирует алгоритмы отправки, квитирования и ARQ-запросов.

На рисунке 9 представлена структурная схема иерархий модели протокола.

Помимо передачи полезной нагрузки, на уровне сессии осуществляется непрерывный мониторинг состояния радиоканала с последующим управлением модуляцией и скоростью кодирования, что определяет пропускную способность канала связи. На рисунке 9 он обозначен как блок "AMC" (Adaptive Modulation and Coding).

Таким образом, комбинация разработанных подуровней формирует высокоуровневый прикладной программный интерфейс передачи данных между удаленными узлами.

Типы сообщений

В предыдущей версии рассматривались только 2 типа сообщений: пакет-маяк и пакет произвольных данных. Поскольку реализация сетевого взаимодействия обуславливает необходимость разделения передаваемой информации на множество функциональных классов, перечень PacketType был значительно расширен.

class PacketType(Enum):
    BEACON = 0
    CONN = 1
    CONN_ACK = 2

    PING = 3
    PONG = 4

    RTS = 5
    CTS = 6

    DATA = 7
    ACK = 8
    NACK = 9
    SACK = 10
    EOT = 11

Под идентификацию пакета пакета в заголовке выделено 4 бита информации, что позволяет определить до 16 разных типов пакетов.

В приведенной реализации управляющие и информационные пакеты классифицированы по функциональным группам.

Пакеты BEACON, CONN, CONN_ACK обеспечивают процедуру установки соединения. Пакеты PING и PONG предназначены для мониторинга параметров канали и поддержки активности соединения. Сигналы RTS (Request To Send), CTS (Clear To Send) информируют о готовности и начале передачи данных. Оставшиеся типы используются для непосредственной передачи полезных данных и подтверждения достоверности приема.

Структуры пакетов

В данном разделе представлены спецификации структур данных, используемых для сериализации и десериализации управляющих и информационных пакетов.

Кодирование числовых значений во всех пакетах осуществляется с применением big-endian порядка.

Beacon

Установка соединения начинается с отправки сообщения общего вызова. Пакет Beacon служит для идентификации вызывающей станции и определения первичных параметры подключения.

Структура пакета:

Суммарный объем информационной емкости пакета составляет 90 бит (11.25 байт).

Режим функционирования маяка определяется значением из BeaconMode.

class BeaconMode(Enum):
    CQ = 0
    CQ_DX = 1
    CQ_AS = 2
    CQ_NA = 3
    CQ_SA = 4
    CQ_EU = 5
    CQ_AF = 6
    CQ_OC = 7
    BEACON = 15

Флаг CQ — циркулярный общий вызов всех корреспондентов; идентификаторы CQ_DX…CQ_OC задают селективный вызов с фильтрацией по географическим регионам. При работе в режиме BEACON установление связи не предусмотрено — станция работает исключительно в режиме периодического информирования о присутствии в эфире.

Реализация пакета:

@bit_packet
@dataclass
class Beacon(PacketCRC8):
    PACKET_TYPE: ClassVar[Final[PacketType]] = PacketType.BEACON

    callsign: str = field(default=CallsignField(53))
    qth: str = field(default=QTHField(25))
    mode: BeaconMode = field(default=EnumField(BeaconMode, 4))

Позывной и QTH-локатор кодируются алгоритмом Base38, аналогично применяемому в протоколе FT-8.

ALPHABET = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ/"
ALPHABET_LEN = len(ALPHABET)

MAX_CALL_LEN = 6
MAX_QTH_LEN = 6


def callsign_to_int(callsign: str) -> int:
    s = callsign.strip().upper()[:MAX_CALL_LEN].ljust(MAX_CALL_LEN, " ")
    val = 0
    for char in s:
        val = val * ALPHABET_LEN + ALPHABET.index(char)
    return val


def int_to_callsign(val: int) -> str:
    chars = []
    for _ in range(MAX_CALL_LEN):
        chars.append(ALPHABET[val % ALPHABET_LEN])
        val //= ALPHABET_LEN
    return "".join(reversed(chars)).strip()


def qth6_to_int(qth: str) -> int:
    q = qth.upper()
    assert len(q) == MAX_QTH_LEN

    off = ord('A')

    lon_field = ord(q[0]) - off
    lat_field = ord(q[1]) - off
    lon_sq = int(q[2])
    lat_sq = int(q[3])
    lon_sub = ord(q[4]) - off
    lat_sub = ord(q[5]) - off

    val = lon_field
    val = val * 18 + lat_field
    val = val * 10 + lon_sq
    val = val * 10 + lat_sq
    val = val * 24 + lon_sub
    val = val * 24 + lat_sub
    return val


def int_to_qth6(val: int) -> str:
    lat_sub = val % 24
    val //= 24
    lon_sub = val % 24
    val //= 24
    lat_sq = val % 10
    val //= 10
    lon_sq = val % 10
    val //= 10
    lat_field = val % 18
    val //= 18
    lon_field = val % 18

    off = ord('A')
    return f"{chr(lon_field + off)}{chr(lat_field + off)}{lon_sq}{lat_sq}{chr(lon_sub + off)}{chr(lat_sub + off)}"

Пример структуры сформированного пакета: Beacon(callsign='R9FEU', qth='LO87cx', mode=<BeaconMode.CQ: 0>)

Битовое представление: 000000000000000000000100001011000100011010011110101100101_1101100011000000001110000_[00100100]

def mod_beacon_signal(self, callsign: str, qth: str,
                      mode: BeaconMode = BeaconMode.BEACON) -> npt.NDArray:
    packet = Beacon(callsign, qth, mode)
    return self.mod_packet_signal(packet, PacketType.BEACON, mod_type=ModType.BPSK, cc_speed=CCSpeed.R13)

Connect

Участник, принявший сигнал Beacon может инициировать установку соединения с узлом, отправляя в эфир пакет Connect, в котором передается позывной вызываемой станции, а также позывной и локатор вызывающей стороны.

Структура пакета:

Суммарный объем информационной емкости пакета составляет 147 бит (18.375 байт).

На данном этапе установки соединения обмен осуществляется с применением радиолюбительских позывных, по которым участники определяют, кому и от кого адресован пакет.

Реализация пакета:

@bit_packet
@dataclass
class Conn(PacketCRC8):
    PACKET_TYPE: ClassVar[Final[PacketType]] = PacketType.CONN

    called: str = field(default=CallsignField(53))
    caller: str = field(default=CallsignField(53))
    qth: str = field(default=QTHField(25))
    caller_conn_id: int = field(default=IntField(8))

    def __post_init__(self):
        assert self.called != self.caller

Пример структуры сформированного пакета: Conn(called='R1ABC', caller='R2ABC', qth='LO88AA', caller_conn_id=1)

Битовое представление: 00000000000000000000010000100100001100000100000000110_00000000000000000000010000100101001011101100100010110_0101110110001101000000000_00000001_[10110111]

Параметры передачи: BPSK, CC ⅓.

def mod_connect_signal(self, called: str, caller: str, caller_qth: str, caller_conn_id: int) -> npt.NDArray:
    packet = Conn(called, caller, caller_qth, caller_conn_id)
    return self.mod_packet_signal(packet, PacketType.CONN, mod_type=ModType.BPSK, cc_speed=CCSpeed.R13)

Connect acknowledge

Подтверждение установки соединения осуществляется отправкой пакета ConnAck со стороны вызываемого. Позывные обеих станций передаются симметрично. Вызываемый подтверждает установление передачей исходного caller_conn_id+1.

Структура пакета:

Суммарный объем информационной емкости пакета составляет 154 бит (19.25 байт).

Реализация пакета:

@bit_packet
@dataclass
class ConnAck(PacketCRC8):
    PACKET_TYPE: ClassVar[Final[PacketType]] = PacketType.CONN_ACK

    caller: str = field(default=CallsignField(53))
    called: str = field(default=CallsignField(53))
    caller_conn_id: int = field(default=IntField(8))
    called_conn_id: int = field(default=IntField(8))

    mod: int = field(default=IntField(8))
    master_window: int = field(default=IntField(8))
    start_lag: int = field(default=IntField(8))

    def __post_init__(self):
        assert self.called != self.caller
        assert 0 < self.master_window < self.mod

Пример структуры сформированного пакета: ConnAck(caller='R2ABC', called='R1ABC', caller_conn_id=1, called_conn_id=1, mod=2, master_window=1, start_lag=30)

Битовое представление: 00000000000000000000010000100101001011101100100010110_00000000000000000000010000100100001100000100000000110_00000001_00000001_00000010_00000001_00011110_[00111111]

Параметры передачи: BPSK, CC ⅓.

def mod_connect_ack_signal(self, caller: str, called: str, caller_conn_id: int, called_conn_id: int, mod: int,
                           master_window: int, start_lag: int) -> npt.NDArray:
    packet = ConnAck(caller, called, caller_conn_id, called_conn_id, mod, master_window, start_lag)
    return self.mod_packet_signal(packet, PacketType.CONN_ACK, mod_type=ModType.BPSK, cc_speed=CCSpeed.R13)

Ping

Короткий пакет-запрос для проверки связи и замера времени отклика между узлами сети. В качестве полезной нагрузки передается значение часов узла-отправителя.

Структура пакета:

Суммарный объем информационной емкости пакета составляет 44 (5.5 байт) бит.

Реализация пакета:

@dataclass
class ConnPacketABC(PacketCRC):
    conn_id: int = field(default=IntField(8))




@dataclass
class ConnTransPacketABC(PacketCRC8, ConnPacketABC):
    trans_id: int = field(default=IntField(8))




@bit_packet
@dataclass
class Ping(ConnTransPacketABC):
    PACKET_TYPE: ClassVar[Final[PacketType]] = PacketType.PING


    time: int = field(default=IntField(20))

Пример структуры сформированного пакета: Ping(conn_id=1, trans_id=2, time=1048570).

Битовое представление: 00000001_000000101_1111111111111111010_[01101111].

Параметры передачи: BPSK, CC ⅓.

def mod_ping_signal(self, conn_id: int, trans_id: int, time: int) -> npt.NDArray:
    packet = Ping(conn_id, trans_id, time)
    return self.mod_packet_signal(packet, PacketType.PING, mod_type=ModType.BPSK, cc_speed=CCSpeed.R13)

Pong

Пакет-ответ на ping-запрос. Отправляется только в ответ на получение пакета ping. В качестве полезной нагрузки возвращает исходное значение времени из ping и добавляет измеренное значение времени после получения и декодирования пакета.

Структура пакета:

Суммарный объем информационной емкости пакета составляет 61 бит (7.625 байт).

Реализация пакета:

@bit_packet
@dataclass
class Pong(ConnTransPacketABC):
    PACKET_TYPE: ClassVar[Final[PacketType]] = PacketType.PONG

    remote_time: int = field(default=IntField(20))
    local_delta: int = field(default=IntField(17))

Пример структуры сформированного пакета: Pong(conn_id=1, trans_id=2, remote_time=86300, local_delta=46300).

Битовое представление: 00000001_00000010_00010101000100011100_01011010011011100_[11011110].

Параметры передачи: BPSK, CC ⅓.

def mod_pong_signal(self, conn_id: int, trans_id: int, remote_time: int, local_delta: int) -> npt.NDArray:
    packet = Pong(conn_id, trans_id, remote_time, local_delta)
    return self.mod_packet_signal(packet, PacketType.PONG, mod_type=ModType.BPSK, cc_speed=CCSpeed.R13)

Request To Send

Пакет-запрос на подтверждение начала передачи блока данных. В пакете передается размер фрейма передаваемых данных в битах и желаемое количество фреймов, которые узел собирается отправить. Также задается тип передаваемых данных: текстовые данные, RSSI, либо же произвольный набор байт.

Структура пакета:

Суммарный объем информационной емкости пакета составляет 44 бит (5.5 байт).

Реализация пакета:

@bit_packet
@dataclass
class RTS(ConnTransPacketABC):
    PACKET_TYPE: ClassVar[Final[PacketType]] = PacketType.RTS

    frame_len: int = field(default=IntField(10))
    frames_count: int = field(default=IntField(8))
    data_type: RTSDataType = field(default=EnumField(RTSDataType, 2))

Значения поля data_type:

class RTSDataType(Enum):
    TEXT = 0
    COMPRESSED_TEXT = 1
    RSSI = 2
    RAW_BYTES = 3

Пример структуры сформированного пакета: RTS(conn_id=1, trans_id=2, frame_len=10, frames_count=5, data_type=<RTSDataType.RAW_BYTES: 3>).

Битовое представление: 00000001_00000010_0000001010_00000101_11_[01110100].

Параметры передачи: BPSK, CC ⅓.

def mod_rts_signal(self, conn_id: int, trans_id: int, frame_len: int, frames_count: int,
                   data_type: RTSDataType) -> npt.NDArray:
    packet = RTS(conn_id, trans_id, frame_len=frame_len, frames_count=frames_count, data_type=data_type)
    return self.mod_packet_signal(packet, PacketType.RTS, mod_type=ModType.BPSK, cc_speed=CCSpeed.R13)

Clear To Send

Пакет-ответ на RTS запрос, подтверждающий или опровергающий готовность принимать данные от отправителя. В пакете передается CTS статус, определяющий готовность или неготовность принимать данные. Также в ответе узел может потребовать от передатчика задать параметры передачи, такие как модуляции и скорость FEC-кодирования.

Структура пакета:

Суммарный объем информационной емкости пакета составляет 31 бит (3.875 байт).

Реализация пакета:

@bit_packet
@dataclass
class CTS(ConnTransPacketABC):
    PACKET_TYPE: ClassVar[Final[PacketType]] = PacketType.CTS

    status: CTSStatus = field(default=EnumField(CTSStatus, 3))
    mod: ModType = field(default=EnumField(ModType, 2))
    speed: CCSpeed = field(default=EnumField(CCSpeed, 2))

Перечень статусов готовности приема:

class CTSStatus(Enum):
    SEND_BULK = 0
    SEND_SIMPLE = 1
    REDUCE = 2  # Reduce frame size
    BUSY = 3  # Wait for next retry
    REJECT = 4  # This data is not interest for me, delete it

Значение SEND_BULK задает режим передачи данных в режиме кучи, при котором передатчик выдает пачкой фреймы данных, при этом приемник единоразово подтверждает какие пакеты он принял.

Статус SEND_SIMPLE задает симплексный режим передачи данных, передатчик работает в режиме Stop-and-Wait, ожидая подтверждения каждого переданного фрейма данных.

REDUCE требует повторного RTS-запроса с измененными данными передачи.

Требование повторить попытку позже определяется значением BUSY .

Статус REJECT — полный отказ и неготовность принимать данные.

Пример структуры сформированного пакета: CTS(conn_id=1, trans_id=2, status=<CTSStatus.SEND_BULK: 0>, mod=<ModType.QAM16: 2>, speed=<CCSpeed.R34: 3>).

Битовое представление: 00000001_00000010_000_10_11_[00000100].

Параметры передачи: BPSK, CC ⅓.

def mod_cts_signal(self, conn_id: int, trans_id: int, status: CTSStatus, mod: ModType = ModType.BPSK,
                   speed: CCSpeed = CCSpeed.R13) -> npt.NDArray:
    packet = CTS(conn_id, trans_id, status=status, mod=mod, speed=speed)
    return self.mod_packet_signal(packet, PacketType.CTS, mod_type=ModType.BPSK, cc_speed=CCSpeed.R13)

End Of Transmission

Сигнализирующий пакет, отправляемый после завершения полного цикла передачи фреймов данных, сигнализируя тем самым о конце передачи.

Структура пакета:

Суммарный объем информационной емкости пакета составляет 26 бит (3.25 байт).

Реализация пакета:

@bit_packet
@dataclass
class Eot(ConnTransPacketABC):
    PACKET_TYPE: ClassVar[Final[PacketType]] = PacketType.EOT

    reason_code: EotReason = field(default=EnumField(EotReason, 2))

Перечень кодов завершения передачи:

class EotReason(Enum):
    SUCCESS = 0
    PARTIAL = 1
    ABORT = 2

Названия значений EotReason говорят сами за себя. На данном этапе реализации используется только код SUCCESS.

Примечание:
PARTIAL предполагается использовать при передаче потоковых данных, ABORT — при прерывании передачи данных пользователем.

Параметры передачи: BPSK, CC ⅓.

def mod_eot_signal(self, conn_id: int, trans_id: int,
                   mod_type: typing.Optional[ModType] = None,
                   cc_speed: typing.Optional[CCSpeed] = None) -> npt.NDArray:
    packet = Eot(conn_id, trans_id, EotReason.SUCCESS)
    return self.mod_packet_signal(packet, PacketType.EOT, mod_type, cc_speed)

Acknowledgment

Пакеты Ack и Nack служат для информирования передающего узла о успешности принятия переданного фрейма данных.

Структура пакетов:

Суммарный объем информационной емкости пакета составляет 32 бит (4 байт).

Реализация пакета:

@bit_packet
@dataclass
class Ack(ConnTransPacketABC):
    PACKET_TYPE: ClassVar[Final[PacketType]] = PacketType.ACK

    frame_id: int = field(default=IntField(8))


@dataclass
class Nack(Ack):
    PACKET_TYPE: ClassVar[Final[PacketType]] = PacketType.NACK

Сигналы Ack и Nack имеют абсолютно одинаковую структуру и отличаются только идентификатором в декодере на PHY-уровне.

Пример структуры сформированного пакета: 
Ack(conn_id=1, trans_id=2, frame_id=3);
Nack(conn_id=1, trans_id=2, frame_id=3).

Битовое представление: 00000001_00000010_00000011_[01100011].

Параметры передачи: BPSK, CC ⅓.

def mod_ack_signal(self, conn_id: int, trans_id: int, frame_id: int,
                   mod_type: typing.Optional[ModType] = None,
                   cc_speed: typing.Optional[CCSpeed] = None) -> npt.NDArray:
    packet = Ack(conn_id, trans_id, frame_id)
    return self.mod_packet_signal(packet, PacketType.ACK, mod_type, cc_speed)

def mod_nack_signal(self, conn_id: int, trans_id: int, frame_id: int,
                    mod_type: typing.Optional[ModType] = None,
                    cc_speed: typing.Optional[CCSpeed] = None) -> npt.NDArray:
    packet = Nack(conn_id, trans_id, frame_id)
    return self.mod_packet_signal(packet, PacketType.NACK, mod_type, cc_speed)

Selective Acknowledgment

Пакет Sack предназначен для селективного подтверждения пачки принятых данных.

Структура пакетов:

Суммарный объем информационной емкости пакета составляет 40 бит (5 байт).

Реализация пакета:

@bit_packet
@dataclass
class Sack(ConnTransPacketABC):
    PACKET_TYPE: ClassVar[Final[PacketType]] = PacketType.SACK

    frame_id: int = field(default=IntField(8))
    mask: int = field(default=IntField(16))

    def is_ok(self, index: int) -> bool:
        return bool(self.mask & (1 << index))

    def is_all_ok(self, count: int) -> bool:
        assert 0 < count <= 16
        mask = (1 << count) - 1
        return (self.mask & mask) == mask

Для маски выделено 16 бит, тем самым одним Sack-пакетом можно подтвердить за раз до 16 фреймов. Значение выбрано как рациональный оптимум для обычной текстовой передачи. Передача больших объемов информации может быть осуществлена изменение размера фреймов в RTS запросе.

Метод is_ok сопоставляет маску с номером бита, соответствующему номеру фрейма из принятой последовательности.

Метод is_all_ok проверяет, что все биты в маске истинны, то есть вся последовательность была принята без ошибок.

Пример структуры сформированного пакета: Sack(conn_id=1, trans_id=2, frame_id=3, mask=15).

Битовое представление: 00000001_00000010_00000011_0000000000001111_[11100111].

Параметры передачи: BPSK, CC ⅓.

def mod_sack_signal(self, conn_id: int, trans_id: int, frame_id: int, mask: int,
                    mod_type: typing.Optional[ModType] = None,
                    cc_speed: typing.Optional[CCSpeed] = None) -> npt.NDArray:
    packet = Sack(conn_id, trans_id, frame_id, mask)
    return self.mod_packet_signal(packet, PacketType.SACK, mod_type, cc_speed)

Data bytes

Транспортный пакет DataBytes, собственно передающий пользовательские данные.

Структура пакета:

Максимальный объем информационной емкости пакета может составлять до 1000 бит (125 байт).

Реализация пакета:

@bit_packet
@dataclass
class DataBytes(PacketCRC16, ConnPacketABC):
    PACKET_TYPE: ClassVar[Final[PacketType]] = PacketType.DATA

    frame_id: int = field(default=IntField(8))
    payload: bytes = field(default=VarBitsField(120 * 8, min_len=1))

Поле payload переменной длины, с ограничением размера в 960 бит. Вместе с CRC-16 передается в хвосте пакета.

Пример структуры сформированного пакета: DataBytes(conn_id=12, frame_id=34, payload=b'\xff\xff\xff').

Битовое представление: 00001100_00100010_111111111111111111111111_[1001001001101101].

Параметры передачи: BPSK/QPSK/16-QAM, CC ⅓ ½ ⅔ ¾.

def mod_data_signal(self, conn_id: int, frame_id: int, data: bytes,
                    mod_type: typing.Optional[ModType] = None,
                    cc_speed: typing.Optional[CCSpeed] = None) -> npt.NDArray:
    packet = DataBytes(conn_id, frame_id, data)
    return self.mod_packet_signal(packet, PacketType.DATA, mod_type, cc_speed)

Единственный тип пакета, который может передаваться с использованием PSK манипуляций высшего порядка и повышенными скоростями сверточного кодера.

Сетевое соединение

Процесс установки сетевого соединения включает в себя широковещательную отправку сигнала вызова и алгоритм тройного рукопожатия (three-way handshake). Диаграмма состояний конечного автомата, функционирующего при установке соединения между двумя узлами, приведена на рисунке 10.

На рисунке 11 представлена временная диаграмма процесса установления соединения между двумя узлами.

Протокольный регламент определяет, что узел, транслирующий общий вызов, принимает статус ведущего (master), в то время как корреспонденты, устанавливающие с ним соединение, — ведомых (slave).

Стадия ожидания запроса на установление связи на стороне ведущего узла функционально аналогична прослушиванию сетевого сокета, с тем отличием, что ведущему необходимо обозначить свое присутствие путем периодической трансляции пакета Beacon с указанием своего позывного и флага CQ. Ведущий узел посылает пакеты CQ Beacon с интервалом в 30 секунд до момента перевода соединения в установленное состояние.

Пример: Beacon(callsign='R1HAM', qth='KO85TR', mode=<BeaconMode.CQ: 0>).

Ведомы узлы, осуществляющие мониторинг канала, обнаруживают указанный пакет и принимают решение о установке соединения с ведущим узлом. Первый этап рукопожатия заключается в отправке пакета Conn ведомым узлом. В канал отправляются позывные ведущего и ведомого узлов, а также QTH-локатор вызывающего. При этом, ведомый узел выбирает произвольное 8-битное число в диапазоне от 0 до 255 для идентификации исходящего своего исходящего подключения.

Пример: Conn(called='R1HAM', caller='R2HOR', qth='KO59DW', caller_conn_id=14).

В 30-и секундных интервалах, между отправкой сигнала маяка, ведущий узел переводится в режим приема для обнаружения адресованных ему запросов установки соединения.

При получении пакета Conn, ведущий принимает решение о возможности организации соединения. В случае положительного решения, ведущий отправляет ConnAck, в котором взаимно подтверждает позывной ведущего, а также подтверждает факт установления соединения отправкой исходного значения caller_conn_id+1. Данная арифметическая операция подтверждает корректность приема и обработки пакета Conn и подтверждает получателя.

Ведущий узел формирует уникальный идентификатор соединения, выбирая произвольное 8-битное значение, и информирует ведомого о том, что все следующие пакеты будут маркироваться этим значением. Это позволяет однозначно отнести поступающие пакеты с этим к текущей установленной сессии.

Примечание:
Ввиду высокой избыточности передачи 53-битных позывных в каждом пакете, было принято решение использовать цифровой идентификатор сессии, а позывные станций передавать в сообщениях на прикладном уровне.

Механизм тайм-слотов

Так как радиообмен происходит в полудуплексном режиме, ведущий узел регламентирует параметры временного разделения каналов, определяя длительность тайм-слотов, в рамках которых узлы осуществляют инициацию передачи исходящих запросов.

Примечание:
В полудуплексном режиме право на инициацию запроса предоставляется тому узлу, текущие системные часы которого соответствуют границам его тайм-слота. При этом вызываемый узел обязан отправить ответ немедленно, по окончании приема.

Поскольку одновременный прием и передача в рамках одного трансивера невозможны, механизм тайм-слотов предназначен для исключения коллизий, возникающих при встречной трансляции в сигналов эфир.

Пример: ConnAck(caller='R2HOR', called='R1HAM', caller_conn_id=15, called_conn_id=31, mod=60, master_window=30, start_lag=30).

Параметры mod и master_window определяют временные границы тайм-слота. Общая длительность одного слота задается значением поля mod в секундах. Значение поля master_window определяет продолжительность временного диапазона, зарезервированного за ведущим узлом. Таким образом, для ведомого узла выделяются интервалы времени, эквивалентные разности mod - master_window секунд.

Примечание:
Поле mod определяет модуль циклического деления текущего целочисленного значения секунд системных часов. Таким образом, при mod=60 значение внутренних часов будет сбрасываться в нулевое значение с периодичностью в 60 секунд.

На рисунке 12 представлена временная диаграмма распределения интервалов внутри тайм-слота. Помимо строгого соблюдения временных окон, на границах слотов предусмотрены защитные интервалы длительностью в несколько секунд для предотвращения коллизий встречной передачи. Этот интервал задан статически и равен 5 секундам.

В динамически меняющемся канале связи с высокой вероятностью потерь, ConnAck может не дойти до корреспондента. Для исключения зацикливания процедуры рукопожатий, ведущий узел в составе ConnAck отправляет поле start_lag. Значение этого поля определяет интервал временного запрета, в течение которого ведомому узлу разрешен только прием входящих пакетов, без права отправки запросов. Таким образом ведущий узел резервирует временной участок для постобработки события установления связи и также гарантирует синхронизацию, при которой ведомому узлу разрешается отправка запросов по истечении защитного интервала в соответствии с общей политикой тайм-слотов.

TIME_MOD = 60
MASTER_WINDOW = 30
START_LAG = 30
GUARD_TIME = 5.0

Триггер тайм-слота:

@property
def tx_allowed(self) -> bool:
    now = int(get_time()
    time_pos = now % self._time_mod
...

Тайм-слот задается значением переменной time_pos на основе системного времени.

...
    is_connecting = self._conn_state.is_connecting

    if self.is_master:
        return is_connecting or time_pos < (self._time_master_wnd - self.GUARD_TIME)
...

На этапе установки соединения передача разрешена безусловно. Для ведущего узла дополнительно осуществляется проверка работы в слоте _time_master_wnd.

...
    if is_connecting or now < self._time_start:
        return False
...

В соответствии с условиям разделения времени, ведомому узлу запрещен выход на передачу до истечения интервала start_lag.

...
    wnd_start = self._time_master_wnd
    wnd_end = self._time_mod - self.GUARD_TIME
    return wnd_start <= time_pos < wnd_end

Проверка попадания в активный слот с учетом защитного интервала GUARD_TIME.

При приеме пакета ConnAck, ведомый узел подтверждает факт установки соединения отправкой сигнала Ack. На этом этапе оба корреспондента взводят флаг о успешном установлении соединения (рисунок 11).

Состояние LISTENING является инвариантным и остается неизменным до момента явного прерывания режима общего вызова. Переходы между другими состояниями автомата определяются значениями внутренних счетчиков повторных попыток установки соединения и таймаутами, по истечении которых соединение переходит в финальное состояние CLOSED.

MAX_RETRANSMITS = 5
RETRANSMIT_TIMEOUT = 10.0

CQ_INTERVAL = 30.0

RX_ACK_EVERY_PACKETS = 5
RX_ACK_TIMEOUT = 2.0

Логика конечного автомата соединения реализуется на верхнем уровне абстракции над декодером.

def process(self, signal: np.ndarray):
    super().process(signal)

    now = get_time()

    if self._conn_state == ConnectionState.LISTENING:
        if now - self._last_cq_time >= self.CQ_INTERVAL:
            self._last_cq_time = now
            self._send_cq()

        return
...

В состоянии LISTENING осуществляется контроль интервалов отправки сигналов CQ-маяка.

...
    if self._conn_state == ConnectionState.CLOSED:
        return
...

При нахождении в состоянии CLOSED блокируется дальнейшая работа логики.

...
    if self._conn_state in (ConnectionState.CONNECTING, ConnectionState.HANDSHAKE):
        if now - self._last_tx_time > self.RETRANSMIT_TIMEOUT:
            if self._retransmit_count >= self.MAX_RETRANSMITS:
                self._set_connection_state(ConnectionState.CLOSED)
                return

            self._retransmit()
            return
...

В состоянии CONNECTING и HANDSHAKE выполняется проверка таймаутов и оценка необходимости повторной отправки запроса.

...
    if self._conn_state == ConnectionState.CONNECTED:
        self._session_loop()

После успешной установки соединения, управление передается в основной цикл обработки сессионного уровня _session_loop.

Функция повторной отправки запроса:

def _retransmit(self) -> None:
    if self._last_signal_sent is not None:
        self._retransmit_count += 1
        self._send_signal(self._last_signal_sent)

Метод _setup_connection определяет параметры тайм-слотов и вычисляет метку t_ime_start на основе значения аргумента start_lag (см. условие проверки выше).

def _setup_connection(self, mod: int, master_window: int, start_lag: int) -> None:
    self._time_mod = mod
    self._time_master_wnd = master_window
    self._time_start = self._detector_time + start_lag

Метод _process_packet вызывается при каждой успешной когда демодуляции пакета на физическом уровне. Таким образом реализуется обработчик входящего потока данных от удаленного узла.

def _process_packet(self, packet: PacketCRC, EsN0_carriers_dB: npt.NDArray[np.float64], EsN0_dB: float,
                    SNR: float, BER: float, speed: float) -> None:
    now = get_time()

    if self._conn_state == ConnectionState.LISTENING:
        self._last_cq_time = now

        if isinstance(packet, Conn) and packet.called == self._callsign:
            if self._can_connect(packet.caller, packet.qth):
                self._remote_callsign = packet.caller
                self._remote_qth = packet.qth
                self._conn_id = self._gen_conn_id()
                self._tmp_conn_id = packet.caller_conn_id

                self._set_connection_state(ConnectionState.HANDSHAKE)
                self._retransmit_count = 0

                self._send_conn_ack()

        return
...

В состоянии LISTENING (ожидание ответа на CQ-запрос) при получении пакета Conn выполняется процедура проверки адресации пакета текущему узлу. Метод _can_connect выполняет вторичную фильтрацию по критериям соответствия позывного ITU-зонам и географическим координатам QTH. При успешном прохождении проверки автомат переводится в состояние трехстороннего рукопожатия HANDSHAKE.

...
    if self._conn_state == ConnectionState.HANDSHAKE:
        if isinstance(packet, Conn) and packet.caller == self._remote_callsign:
            if self._last_signal_sent is not None:
                self._send_signal(self._last_signal_sent)

            return

        if isinstance(packet, Ack) and packet.conn_id == self._conn_id:
            self._set_connection_state(ConnectionState.CONNECTED)
            self._handle_connected()
            self._time_start = now
            self._last_signal_sent = None

        return
...

В состоянии HANDSHAKE узел осуществляет проверку статуса соединения. Если удаленный узел подтверждает соединение отправкой корректного conn_id, соединение переводится в состояние CONNECTED с вызовом события _handle_connected.

В случае, если узел дублирует отправку Conn (например из-за потерь в канале связи), оппонент дублирует Ack-подтверждение.

...
    if self._conn_state == ConnectionState.CONNECTING:
        if isinstance(packet,
                      ConnAck) and packet.caller == self._callsign and packet.called == self._remote_callsign:
            if packet.caller_conn_id != self._tmp_conn_id + 1:
                self._set_connection_state(ConnectionState.CLOSED)
                return

            self._conn_id = packet.called_conn_id
            signal = self.modem.mod_ack_signal(self._conn_id, self._get_seq_id(),
                                               frame_id=0)  # target_id here is zero
            self._send_signal(signal)

            self._set_connection_state(ConnectionState.CONNECTED)
            self._handle_connected()
            self._setup_connection(packet.mod, packet.master_window, packet.start_lag)
            self._last_signal_sent = None

        return
...

Состояние CONNECTING устанавливается при формировании исходящего соединения (метод connect_to). В данном состоянии осуществляются проверки ответов от ведущего узла. Пакет ConnAck считается подтвержденным при условии решения задачи с инкрементом +1 к отправляемому _tmp_conn_id.

...
    if self._conn_state == ConnectionState.CONNECTED:
        if isinstance(packet, ConnAck) and packet.called_conn_id == self._conn_id:
            signal = self.modem.mod_ack_signal(self._conn_id, self._get_seq_id(),
                                               frame_id=0)  # target_id here is zero
            self._send_signal(signal)
            return

        kwargs = dict(EsN0_carriers_dB=EsN0_carriers_dB, EsN0_dB=EsN0_dB, SNR=SNR, BER=BER)

        if isinstance(packet, ConnPacketABC) and packet.conn_id == self._conn_id:
            self._handle_session_packet(packet, **kwargs)
            return

        self._handle_unknown_packet(packet, **kwargs)
        return

В состоянии CONNECTED выполняется фильтрация входящих пакетов на соответствие connid текущему идентификатору соединения. Пакеты, прошедшие проверку, передаются в _handle_session_packet для обработки на уровне сессии. Пакеты не прошедшие проверку пересылаются в обработчик _handle_unknown_packet.

Сессия

После успешной установки соединения между узлами устанавливается сессия, реализующая уровень абстракции для организации пакетной передачи данных.

На сессионном уровне реализуется передача данных с применением алгоритма автоматического запроса повторной передачи (ARQ, Automatic Repeat reQuest).

Пакетная передача

По причине низкой надежности передачи значительных объемов пользовательских данных единым массивом в нестабильном радиоканале, передаваемые данные фрагментируются на блоки небольшого размера.

При такой реализации базовым методом передачи сообщения является поочередная отправка каждого блока данных с последующим ожиданием подтверждения его доставки (рисунок 13).

Передача осуществляется с того, что участник в границах своего активного тайм-слота передает RTS запрос. После приема пакета CTS выполняется отправка первого блока данных, после чего передающий узел переходит в состояние ожидания с остановкой (Stop-and-Wait) для проверки доставки пакета. В случае потери пакета или нарушения целостности данных передающий узел инициирует повторную отправку текущего блока данных.

При успешном приеме подтверждения система переходит к передаче следующего блока данных. Этот цикл повторяется до полной отправки всего массива данных.

Финальный EOF-пакет служит индикатором кона передачи. Логически этот пакет интегрирован в общую структуру передаваемых данных и к нему применяется аналогичный алгоритм подтверждения и ARQ-запроса.

Таким образом реализуется режим передачи SEND_SIMPLE. Данный алгоритм характеризуется наименьшей пропускной способностью, поскольку требует строго последовательной отправки блоков и ожидания их подтверждения. Мгновенная скорость передачи данных при этом может быть высокой (в зависимости от размера пакета и применяемой в нем модуляции), но интегральная скорость обмена сильно снижается из-за больших задержек (пинга) и оверхеда, вызываемого служебным трафиком.

Bulk-передача

Bulk-передача (рисунок 14) представляет собой альтернативный метод высокоскоростной передачи данных, при котором последовательность блоков данных передается в эфир непрерывным потоком, а принимающий узел осуществляет групповое подтверждение корректно доставленных блоков.

После принятия EOT-пакета, принимающая сторона формирует Sack-пакет. Содержащаяся в нем битовая маска определяет какие статус доставки каждого отдельного блока.

Передающая сторона анализирует битовую маску и инициирует повторную отправку только тех блоков, доставка которых завершилась ошибкой. Данный цикл итерационно повторяется до момента подтверждения доставки всех блоков передаваемых данных (рисунок 15).

Таким образом, использование bulk-режима позволяет существенно повысить интегральную скорость доставки данных и минимизировать временные издержки на служебный трафик.

Проверка соединения

Поскольку ведущий узел резервирует часть временного интервала в тайм-слоте для собственных нужд, инициализация сессионного цикла начинается с проверки соединения посредством отправки ping-запроса. Ведомый узел формирует pong-ответ (рисунок 16).

Анализ времени задержки ping-запроса позволяет оценить скорость работы модемов при кодировании и декодирования пакетов, а также определить статистическую вероятность потери пакетов в канале.

На рисунке 17 приведен граф состояний работы сессии.

Общий перечень внутренних состояний автомата описывается структурой:

class SessionState(Enum):
    IDLE = 0

    PING_AWAIT = 1

    CTS_AWAIT = 2

    DATA_TRANSFER = 3
    DATA_CONFIRM_AWAIT = 4

    DATA_AWAIT = 5
    EOT_ACK_AWAIT = 6

    @property
    def is_awaiting(self) -> bool:
        cls = self.__class__

        return self in (
            cls.PING_AWAIT, cls.CTS_AWAIT, cls.DATA_CONFIRM_AWAIT, cls.DATA_AWAIT, cls.EOT_ACK_AWAIT
        )

Параметры работы FSM логики сессии включают в себя следующие значениями:

class Session(Connection):
    PING_INTERVAL = 60.0  # sec
    DEFAULT_RTS_INTERVAL = 20.0  # sec
    DEFAULT_FRAME_LEN = 40 * 8  # bits
    MAX_FRAMES = 1 << 8

    DEFAULT_IDLE_TIMEOUT = 180.0

Значение PING_INTERVAL определяет как часто в состоянии IDLE будет осуществляться отправка Ping-запроса от ведущего узла к ведомому.

Параметр DEFAULT_RTS_INTERVAL задает временной интервал между циклами отправки RTS-запросов.

Значение DEFAULT_FRAME_LEN определяет верхнюю границу размера размера единичного блока данных (соответствующему пакету Data).

Параметр MAX_FRAMES задает максимальное количество блоков выделяемых в рамках одной пакетной сессии.

Значение DEFAULT_IDLE_TIMEOUT задает временной интервал отсутствия активности, по истечении которого сессия переводится в состояние неактивной.

Метод _session_loop реализует алгоритм перехода состояний конечного автомата сессии:

def _session_loop(self):
    now = get_time()

    if self._last_tx_tms is not None and now - self._last_tx_tms > self.DEFAULT_IDLE_TIMEOUT:
        self.close()
        return

    if self._session_state != SessionState.IDLE:
        if now - self._last_progress_tms > self._activity_timeout:
            if self._session_state == SessionState.DATA_AWAIT:
                self._tx_block = None
                self._set_session_state(SessionState.IDLE)
                self._rx_buffer.clear()
                self._rx_buffer_dtype = None
                self._rx_pending_payloads.clear()
                return
            elif now - self._last_signal_tms > self._activity_timeout:
                self._tx_block = None
                self._set_session_state(SessionState.IDLE)
                return
...

Контроль тайм-аута сессии: при превышении значения _activity_timeout автомат переводит сессию в состояние IDLE. При преодолении критического порога DEFAULT_IDLE_TIMEOUT сессия завершается.

...
    is_session_active = self._session_state not in (SessionState.IDLE, SessionState.PING_AWAIT)

    if is_session_active:
        self.rx_packets_since_last_ack = 0

    if self.is_master:
        if self._session_state == SessionState.IDLE and now - self._last_ping_time > self.PING_INTERVAL:
            self._last_ping_time = now
            signal = self.modem.mod_ping_signal(
                self._conn_id, trans_id=self._get_seq_id(), time=time_monotonic_ms(self.MONOTONIC_TIME_MOD)
            )
            self._set_session_state(SessionState.PING_AWAIT)
            self._send_signal(signal)
            return
...

В первом тайм-слоте ведущий узел осуществляет оценку канала путем отправки Ping-запроса. Ожидание ответного пакета Pong осуществляется в состоянии PING_AWAIT.

...
    if (self._session_state == SessionState.IDLE
            and len(self._tx_buffer) > 0
            and self.tx_allowed
            and (now - self._last_ping_time > self.GUARD_TIME
)):

        assert self._tx_block is None
        assert len(self._tx_buffer) < self._max_tx_block_len

        self._tx_block = TXBlock(
            frame_len=self._frame_len,
            data=self._tx_buffer[0],
            rts_interval=self.DEFAULT_RTS_INTERVAL,
            last_rts=now
        )
        self._tx_block.retry_count = 0

        signal = self.modem.mod_rts_signal(
            self._conn_id, trans_id=self._get_seq_id(),
            **self._tx_block.get_rts_args()
        )
        self._set_session_state(SessionState.CTS_AWAIT)
        self._send_signal(signal)
        return
...

В состоянии IDLE происходит циклическая проверка буфера исходящих данных. При совпадении временных интервалов с границами активного тайм-слота формируется объект TXBlock (см. далее), выполняющий фрагментацию исходного массива данных на блоки и инкапсулирующий текущий контекст передачи.

Осуществляется отправка сигнала RTS, после чего автомат переходит в состояние CTS_AWAIT для мониторинга поступающих CTS-ответов.

...
    elif self._session_state == SessionState.CTS_AWAIT and self.tx_allowed:
        if self._tx_block is not None and now - self._tx_block.last_rts > self._tx_block.rts_interval:
            if self._tx_block.retry_count >= self._tx_block.max_retries:
                self._tx_block = None
                self._set_session_state(SessionState.IDLE)
                self.close()
                return

            self._tx_block.retry_count += 1
            self._tx_block.last_rts = now
            signal = self.modem.mod_rts_signal(
                self._conn_id, trans_id=self._get_seq_id(),
                **self._tx_block.get_rts_args()
            )
            self._send_signal(signal)
        return
...

Проверка системных таймеров и повторная передача RTS выполняется в состоянии CTS_AWAIT. Переменная retry_count регистрирует число итераций отправки запросов.

...
    elif self._session_state == SessionState.DATA_TRANSFER and self.tx_allowed:
        if not self._tx_block.eof:
            wire_frame_id = self._tx_block.current_frame_idx % 256
            signal = self.modem.mod_data_signal(
                self._conn_id, frame_id=wire_frame_id, data=self._tx_block.current_data_block,
                **self._get_data_signal_extra_args()
           )
            self._tx_block.last_tx_time = now
            self._tx_block.retry_count = 0

            if self._current_cts_status == CTSStatus.SEND_BULK:
                self._tx_block.pop_current_frame()
            else:
                self._set_session_state(SessionState.DATA_CONFIRM_AWAIT)

            self._send_signal(signal)
            return
        else:
            self._set_session_state(SessionState.EOT_ACK_AWAIT)
            if self._tx_block.eot_trans_id == 0:
                self._tx_block.eot_trans_id = self._gen_trans_id()

            signal = self.modem.mod_eot_signal(self._conn_id, trans_id=self._tx_block.eot_trans_id)
            self._tx_block.last_tx_time = now
            self._tx_block.retry_count = 0
            self._send_signal(signal)
            return
...

В состоянии DATA_TRANSFER, являющимся основным при обмене данными, происходит последовательное извлечение блоков из структуры _tx_block и их отправка в канал. По завершении отправки всего массива данных, при истинности условия self._tx_block.eof отправляется EOT-сигнал, после чего автомат переходит в состояние ожидания подтверждения принятия EOT (EOT_ACK_AWAIT).

На данном этапе реализуются оба режима пакетной передачи: Bulk и Stop-and-Wait, что определяется переменной состояния _current_cts_status.

...
    elif self._session_state == SessionState.DATA_CONFIRM_AWAIT and self.tx_allowed:
        if now - self._tx_block.last_tx_time > self._tx_block.retry_timeout:
            if self._tx_block.retry_count >= self._tx_block.max_retries:
                self._tx_block = None
                self._set_session_state(SessionState.IDLE)
                self.close()
                return

            self._tx_block.retry_count += 1
            self._tx_block.last_tx_time = now

            wire_frame_id = self._tx_block.current_frame_idx % 256
            signal = self.modem.mod_data_signal(
                self._conn_id, frame_id=wire_frame_id, data=self._tx_block.current_data_block,
                **self._get_data_signal_extra_args()
           )
            self._send_signal(signal)
        return
...

Состояние DATA_CONFIRM_AWAIT управляет итерационным процессом передачи данных в режиме Stop-and-Wait.

...
    elif self._session_state == SessionState.EOT_ACK_AWAIT and self.tx_allowed:
        if now - self._tx_block.last_tx_time > self._tx_block.retry_timeout:
            if self._tx_block.retry_count >= self._tx_block.max_retries:
                self._tx_block = None
                self._set_session_state(SessionState.IDLE)
                self.close()
                return

            self._tx_block.retry_count += 1
            self._tx_block.last_tx_time = now
            signal = self.modem.mod_eot_signal(self._conn_id, trans_id=self._tx_block.eot_trans_id)
            self._send_signal(signal)
        return

Повторная отправка EOT-пакета и инкремент счетчика retry_count выполняются в состоянии EOT_ACK_AWAIT. При превышении retry_count лимита сессия сбрасывается в исходное состояние IDLE.

Поскольку логика работы конечных автоматов разнесена на разные уровни событий (события внутренних таймеров и событий прерывания от модема), метод _handle_session_packet реализует обработку ответов, поступающих от удаленного узла.

def _handle_session_packet(self, packet: PacketCRC, **kwargs) -> None:
    now = get_time()

    self._last_signal_tms = now
    self._last_tx_tms = now

    if isinstance(packet, Ping):
        delta_ms = int((now - self._detector_time) * 1000)
        signal = self.modem.mod_pong_signal(
            self._conn_id, trans_id=packet.trans_id, remote_time=packet.time, local_delta=delta_ms
        )
        self._send_signal(signal)
        return
...

Обработка Ping-запроса. Осуществляется мгновенная отправка пакета Pong.

...
    if isinstance(packet, Pong):
        if self._session_state != SessionState.PING_AWAIT:
            self._handle_unexpected_packet(packet)


        delta_ms = monotonic_delta(
            time_monotonic_ms(self.MONOTONIC_TIME_MOD), packet.remote_time, self.MONOTONIC_TIME_MOD
        )
        self._ping_ms = delta_ms - packet.local_delta
        self._handle_ping(self._ping_ms)


        self._set_session_state(SessionState.IDLE)
        return
...

Обработка Ping-ответа: автомат сессии выходит из состояния PING_AWAIT и переходит в состояние IDLE.

Поскольку для вычисления задержки передачи сигнала используется миллисекундная точность, значение монотонного системного таймера вычисляется по модулю MONOTONIC_TIME_MOD (1048576, что эквивалентно временному окну переполнения порядка 30 минут).

...
    if isinstance(packet, RTS):
        if self._session_state == SessionState.EOT_ACK_AWAIT:
            if self._tx_block is not None:
                self._tx_block.tx_allowed = False
                self._tx_block.retry_count = 0

        status = self._handle_rts(packet.frame_len, packet.frames_count, packet.data_type)

        if status == CTSStatus.REDUCE:
            self._set_session_state(SessionState.IDLE)
        else:
            self._set_session_state(SessionState.DATA_AWAIT)
            self._rx_expected_seq = 0
            self._rx_expected_count = packet.frames_count
            self._rx_pending_payloads.clear()
            self._rx_session_mode = CTSStatus.SEND_BULK

        signal = self.modem.mod_cts_signal(
            self._conn_id, trans_id=packet.trans_id, status=status, **self._get_cts_signal_extra_args()
        )
        self._send_signal(signal)
        return
...

Обработка запроса RTS: принимающий участник осуществляет подготовку приемного буфера для последующего накопления принимаемых данных и отправляет пакет разрешения передачи. Режим bulk-передачи задан статически флагом SEND_BULK. Тем не менее, архитектура предусматривает возможность изменения типа передачи на пользовательском уровне.

...
    if isinstance(packet, CTS):
        if packet.status == CTSStatus.REDUCE:
            self._frame_len = self.DEFAULT_FRAME_LEN
            self._tx_block = None

            self._set_session_state(SessionState.IDLE)
            return

        if packet.status in (CTSStatus.SEND_BULK, CTSStatus.SEND_SIMPLE):
            assert self._tx_block is not None
            self._current_cts_status = packet.status

            self._tx_block.tx_allowed = True
            self._set_session_state(SessionState.DATA_TRANSFER)
            return

        if packet.status == CTSStatus.REJECT:
            self._tx_block = None
            self._set_session_state(SessionState.IDLE)
            return
        return
...

На основе анализа статуса CTS ответа, передающий узел принимает решение о начале передачи, переводя конечный автомат в состояние на DATA_TRANSFER. В случае отрицательного ответа, происходит отмена передачи, выделенный буфер освобождается, а автомат сессии возвращается в состояние IDLE.

...
    if isinstance(packet, (DataBytes, Eot)):
        if isinstance(packet, Eot) and self._session_state == SessionState.IDLE:
            signal = self.modem.mod_ack_signal(self._conn_id, trans_id=packet.trans_id, frame_id=0)
            self._send_signal(signal)
            return

        if self._session_state != SessionState.DATA_AWAIT:
            self._handle_unexpected_packet(packet)
            return
...

Прием и обработка входящего потока данных. При получении пакетов вне активного состояния DATA_AWAIT вызывается обработчик _handle_unexpected_packet.

...
        if isinstance(packet, DataBytes):
            self._last_progress_tms = now


            diff = (packet.frame_id - self._rx_expected_seq) % 256
            if diff > 128:
                if self._rx_session_mode != CTSStatus.SEND_BULK:
                    signal = self.modem.mod_ack_signal(self._conn_id, trans_id=self._gen_trans_id(),
                                                      frame_id=packet.frame_id)
                    self._send_signal(signal)
                return
...

Алгоритм проверка расхождения идентификаторов блоков при их возможной потере и циклического переполнения счетчика при длительных сеансах непрерывной связи.

...
            if packet.frame_id not in self._rx_pending_payloads:
                self._rx_pending_payloads[packet.frame_id] = packet.payload

            moved = False
            while self._rx_expected_seq in self._rx_pending_payloads:
                payload = self._rx_pending_payloads.pop(self._rx_expected_seq)
                self._handle_rx_data(payload)
                self._rx_expected_seq = (self._rx_expected_seq + 1) % 256
                moved = True
...

Принятые блоки данных накапливаются в промежуточном буфере _rx_pending_payloads.

...
            if packet.frame_id != self._rx_expected_seq and not moved:
                if self._rx_session_mode != CTSStatus.SEND_BULK:
                    signal = self.modem.mod_nack_signal(self._conn_id, frame_id=self._rx_expected_seq)
                    self._send_signal(signal)
                return
...

В режиме передачи Stop-and-Wait узел-получатель формирует Nack ответ при обнаружении расхождения между индексом принятого и ожидаемым значением указателя _rx_expected_seq.

...
            if self._rx_session_mode != CTSStatus.SEND_BULK:
                signal = self.modem.mod_ack_signal(self._conn_id, trans_id=self._gen_trans_id(),
                                                  frame_id=packet.frame_id)
                self._send_signal(signal)
            return
...

Формирование и отправка подтверждение принятия блока данных.

...
        else:
            if self._rx_session_mode == CTSStatus.SEND_BULK:
                block_mask = 0
                for idx in range(self._rx_expected_count):
                    if idx < self._rx_expected_seq or idx in self._rx_pending_payloads:
                        block_mask |= (1 << idx)

                signal = self.modem.mod_sack_signal(
                    self._conn_id, trans_id=packet.trans_id, frame_id=0, mask=block_mask
                )
                self._send_signal(signal)

                if self._rx_expected_seq == self._rx_expected_count and len(self._rx_pending_payloads) == 0:
                    self._last_rx_trans_id = packet.trans_id
                    self._last_rx_total_count = self._rx_expected_count
                    self._last_rx_mask = block_mask

                    self._set_session_state(SessionState.IDLE)
                    self._handle_rx_eot()
                    self._last_ping_time = now
                else:
                    self._set_session_state(SessionState.DATA_AWAIT)
...

Обработка EOT-пакета. При функционировании в режиме Bulk на основе принятых в _rx_pending_payloads ключей формируется битовая маска block_mask.

Сформированная маска отправляется в составе Sack-пакета.

...
            else:
                signal = self.modem.mod_ack_signal(self._conn_id, trans_id=packet.trans_id, frame_id=0)
                self._send_signal(signal)
                self._set_session_state(SessionState.IDLE)
                self._handle_rx_eot()
                self._last_ping_time = now


            return
...

В режиме Stop-and-Wait выполняется стандартное подтверждение принятия пакета EOT.

...
    if isinstance(packet, Ack):
        if self._tx_block is None:
            self._handle_unexpected_packet(packet)
            return

        if self._session_state == SessionState.DATA_CONFIRM_AWAIT:
            self._tx_block.pop_current_frame()
            self._set_session_state(SessionState.DATA_TRANSFER)
            return

        if self._session_state == SessionState.EOT_ACK_AWAIT:
            if packet.trans_id == self._tx_block.eot_trans_id:
                if len(self._tx_buffer) > 0:
                    del self._tx_buffer[0]

                self._tx_block = None
                self._set_session_state(SessionState.IDLE)
                self._last_ping_time = now
                return

            self._handle_unexpected_packet(packet)
            return
        return
...

Обработка Ack-пакета. При получении этого пакета передающий узел исключает успешно переданный блок данных из очереди отправки и переключается на следующий блок. Если сессия находилась в состоянии EOT_ACK_AWAIT, из буфера _tx_buffer удаляется массив данных, эквивалентный завершенной транзакции в текущей сессии.

...
    if isinstance(packet, Nack):
        if self._session_state in (SessionState.DATA_TRANSFER, SessionState.DATA_CONFIRM_AWAIT) and self._tx_block:
            failed_frame_idx = packet.frame_id

            if failed_frame_idx not in self._tx_block._frames_to_tx:
                self._tx_block._frames_to_tx.insert(0, failed_frame_idx)

            self._tx_block.retry_count = 0
            self._set_session_state(SessionState.DATA_TRANSFER)
        return
...

При получении Nack ответа передаваемый блок данных возвращается обратно в очередь для повторной отправки.

...
    if isinstance(packet, Sack):
        if self._tx_block is None:
            self._handle_unexpected_packet(packet)
            return

        if self._session_state == SessionState.EOT_ACK_AWAIT:
            if packet.trans_id != self._tx_block.eot_trans_id:
                self._handle_unexpected_packet(packet)
                return

            total_frames = self._tx_block.data_blocks_count

            if packet.is_all_ok(total_frames):
                if len(self._tx_buffer) > 0:
                    del self._tx_buffer[0]

                self._tx_block = None
                self._set_session_state(SessionState.IDLE)
                self._last_ping_time = now
            else:
                failed_frames = []
                for idx in range(total_frames):
                    if not packet.is_ok(idx):
                        failed_frames.append(idx)

                self._tx_block._frames_to_tx = failed_frames
                self._tx_block.retry_count = 0
                self._set_session_state(SessionState.DATA_TRANSFER)
            return
        return

Структура TXBlock сохраняет текущее состояние активного сеанса передачи данных:

@dataclass
class TXBlock:
    frame_len: int  # bits
    data: SessionBytes
    rts_interval: float

    retry_timeout: float = 10.0
    max_retries: int = 5

    last_rts: float = 0.0
    tx_allowed: bool = False

    _frames_to_tx: list = None

    last_tx_time: float = 0.0
    retry_count: int = 0
    eot_trans_id: int = 0

    def __post_init__(self):
        if self._frames_to_tx is None:
            self._frames_to_tx = list(range(self.data_blocks_count))

    def get_rts_args(self) -> dict:
        data_type = self.data.RTS_DATA_TYPE

        return dict(frame_len=self.frame_len, frames_count=self.data_blocks_count, data_type=data_type, )

    @property
    def data_block_len(self) -> int:
        return math.ceil(self.frame_len / 8)
...

Определение размера блока данных (в байтах) для алгоритма скользящего окна.

...
    @property
    def data_blocks_count(self) -> int:
        return math.ceil(len(self.data) / self.data_block_len)
...

Определение общего количества блоков данных для алгоритма скользящего окна.

...
    def get_data_block(self, block_num: int) -> bytes:
        assert 0 <= block_num < self.data_blocks_count
        return self.data[block_num * self.data_block_len:(block_num + 1) * self.data_block_len]

    @property
    def current_frame_idx(self) -> int:
        assert not self.eof
        return self._frames_to_tx[0]

    @property
    def current_data_block(self) -> bytes:
        return self.get_data_block(self.current_frame_idx)
...

Получение массива байт, соответствующему текущему индексируемому блоку данных.

...
    def pop_current_frame(self) -> int:
        return self._frames_to_tx.pop(0)

    @property
    def eof(self) -> bool:
        return len(self._frames_to_tx) == 0

Метод pop_current_frame извлекает из стека следующий блок данных для отправки.
Свойство eof осуществляет проверку на предмет исчерпания данных в очереди.

Изменение скорости передачи

По умолчанию, передача осуществляется с применением модуляции BPSK и скоростью ⅓ сверточного кодера. Это обеспечивает максимальную избыточность и помехоустойчивость в условиях сильных искажений, но снижает пропускную способность до минимального уровня.

При высоком отношении сигнал/шум использовании минимальной скорости неэффективно. Адаптация скорости обмена реализуется пороговым методом: принимающая сторона оценивает текущие параметры канала и в ответных пакетах CTS указывает оптимальную схему модуляции и скорость кодирования для последующих циклов передачи данных (рисунок 18).

Алгоритм адаптивного управления скоростью функционирует на уровне выше относительно логики сессии.

class AMCSession(Session):
    SNR_HISTORY_DEEP = 10
    BER_HISTORY_DEEP = 10

    QPSK_FRAME_LEN = 80 * 8  # bits
    QAM16_FRAME_LEN = 120 * 8  # bits

    MOD_FRAME_LEN = {
        ModType.QPSK: QPSK_FRAME_LEN,
        ModType.QAM16: QAM16_FRAME_LEN
    }

Параметры канала оцениваются через вычисления медианных значений BER и SNR по накопленной истории полученных пакетов.

Глубина скользящего окна измерений определяется значениями SNR_HISTORY_DEEP и BER_HISTORY_DEEP.

Использование высокоуровневых схем модуляции увеличивает информационную емкость пакета при той же длительности сигнала. Размер блока данных для режимов QPSK и 16-QAM задается значениями QPSK_FRAME_LEN и QAM16_FRAME_LEN.

Примечание:
Значения подобраны эмпирически.

Метод _handle_session_packet получает от модема метрики BER и SNR, тем самым формируя историю измерений.

def _handle_session_packet(self, packet: PacketCRC, **kwargs) -> None:
    assert "SNR" in kwargs
    assert "BER" in kwargs

    self._snr_history.append(kwargs["SNR"])
    self._ber_history.append(kwargs["BER"])

    if isinstance(packet, CTS):
        if packet.status in (CTSStatus.SEND_BULK, CTSStatus.SEND_SIMPLE):
            self._data_mod_type = packet.mod
            self._data_cc_speed = packet.speed
            self._frame_len = self.MOD_FRAME_LEN.get(self._data_mod_type, self.DEFAULT_FRAME_LEN)

    return super()._handle_session_packet(packet, **kwargs)

При получении CTS ответа, сессионный уровень переключается на принятые параметры модуляции и скорости кодера.

Таблица выбора модуляции и скорости кодера:

Примечание:
Схема 32-QAM была добавлена в процессе окончания написания статьи, вследствии чего она не прошла полный цикл испытаний и не включена в общий алгоритм изменения скорости.

Метод _calc_link_parameters анализирует усредненные метрики BER и SNR, вычисляя оптимальный тип модуляции и скорость кодирования под текущие условия.

@property
def median_snr(self) -> typing.Optional[float]:
    if len(self._snr_history) < 2:
        return None

    return float(np.median(list(self._snr_history)))

@property
def median_ber(self) -> typing.Optional[float]:
    if len(self._ber_history) < 2:
        return None

    return float(np.median(list(self._ber_history)))

def _calc_link_parameters(self) -> typing.Tuple[ModType, CCSpeed]:
    snr = self.median_snr
    ber = self.median_ber

    if snr is None or ber is None:
        return ModType.BPSK, CCSpeed.R13

    if snr < -4.0:
        return ModType.BPSK, CCSpeed.R13

    elif snr < 1.0:
        return ModType.BPSK, CCSpeed.R12

    elif snr < 4.5:
        if ber < 0.01:
            return ModType.QPSK, CCSpeed.R12
        return ModType.QPSK, CCSpeed.R13

    elif snr < 7.5:
        return ModType.QPSK, CCSpeed.R34

    else:
        if ber > 0.005:
            return ModType.QAM16, CCSpeed.R13

    return ModType.QAM16, CCSpeed.R12

Обработка RTS-запроса:

def _handle_rts(self, frame_len: int, frames_count: int, data_type: RTSDataType) -> CTSStatus:
    base_status = super()._handle_rts(frame_len, frames_count, data_type)
    if base_status == CTSStatus.REJECT:
        return base_status

    mod, _ = self._calc_link_parameters()

    if frame_len > self.DEFAULT_FRAME_LEN and mod != ModType.QAM16:
        return CTSStatus.REDUCE

    return base_status

Если накопленная статистика на принимающей стороне указывает на ухудшение условий для текущего блока, узел  формирует ответ со статусом REDUCE, требуя изменить параметры передачи.

Динамика изменения пропускной способности при смене схем модуляции и кодирования представлена на рисунке 19.

При лабораторных испытаниях в условиях отсутствия помех пиковая скорость передачи (рассчитанная как отношение объема полезной нагрузки к длительности пакета) составила 1542.65 бит/с.

Примечание:
При этом пинг составлял 5964 мс. Значение сильно зависит от размера буфера при захвате данных со звуковой карты, а также добавлении принудительных пауз при передаче сигналов в звуковую карту.
Также необходимо отметить, что при 32-QAM модуляции скорость передачи будет еще выше.

Передача данных прикладного уровня

На сессионном уровне передаваемые данные не классифицируются на тип передаваемой информации и обрабатываются как массив байт. На прикладном уровне данные разделяются на две категории: текстовые сообщения и произвольные бинарные данные.

Для повышения скорости обмена текстовой информацией предусмотрен режим сжатия. Юникод-текст сжимается алгоритмом unishox2. При передаче сжатых данных в RTS запросе выставляется флаг COMPRESSED_TEXT.

Предварительная обработка и преобразование данных перед отправкой осуществляется кодеками на базе абстрактного класса SessionBytes.

class SessionBytes(bytes):
    RTS_DATA_TYPE = None

    def __new__(cls, payload: typing.Union[str, bytes]):
        assert cls.RTS_DATA_TYPE is not None
        assert cls.RTS_DATA_TYPE in RTS_DATA_TYPES

        data = cls._to_bytes(payload)
        return super().__new__(cls, data)

    @classmethod
    @abstractmethod
    def _to_bytes(cls, payload: typing.Union[str, bytes]) -> bytes:
        ...

    @abstractmethod
    def from_bytes(self) -> typing.Union[str, bytes]:
        ...

Текстовые данные формата UTF-8 сериализуются в массив байт, а при декодировании выполняется обратное действие.

class TextBytes(SessionBytes):
    RTS_DATA_TYPE = RTSDataType.TEXT

    @classmethod
    def _to_bytes(cls, payload: typing.Union[str, bytes]) -> bytes:
        if isinstance(payload, bytes):
            return payload

        return payload.encode("utf-8", errors="ignore")

    def from_bytes(self) -> typing.Union[str, bytes]:
        return self.decode("utf-8", errors="ignore")

Класс TextCompressedBytes инкапсулирует алгоритмы компрессии и декомпрессии байт в UTF-8 строки.

class TextCompressedBytes(SessionBytes):
    RTS_DATA_TYPE = RTSDataType.COMPRESSED_TEXT

    @classmethod
    def _to_bytes(cls, payload: typing.Union[str, bytes]) -> bytes:
        if isinstance(payload, bytes):
            return payload

        compressed, _ = unishox2.compress(payload)
        return compressed

    def from_bytes(self) -> typing.Union[str, bytes]:
        decompressed = unishox2.decompress(self, 4096)
        return decompressed

Произвольные двоичные данные передаются без предварительных преобразований. Кодек RawBytes выполняет роль заглушки обеспечивая однозначную идентификацию типа данных при их передаче на прикладной уровень.

class RawBytes(SessionBytes):
    RTS_DATA_TYPE = RTSDataType.RAW_BYTES

    @classmethod
    def _to_bytes(cls, payload: typing.Union[str, bytes]) -> bytes:
        return payload

    def from_bytes(self) -> typing.Union[str, bytes]:
        return self

Запуск диалога между двумя узлами

Работоспособность MAC и LLC уровней проверялась путем запуска двух узлов с общим звуковым каналом, обеспечивающей взаимную передачу звукового сигнала. Для параллельного мониторинга сигнальных созвездий в схему испытаний был интегрирован сниффер (рисунок 20).

23:20:26 [   INFO] Start server (R1HAM @ KO85TR)...
23:20:26 [   INFO] Found device: Monitor of Meteor Lake-P HD Audio Controller Speaker
23:20:26 [   INFO] Channels: 2
23:20:26 [   INFO] Init sound output...
23:20:27 [   INFO] Start semiduplex connection...
23:20:35 [   INFO] Received packet: Conn(called='R1HAM', caller='R2HOR', qth='KO59DW', caller_conn_id=184)
23:20:42 [   INFO] --- Hamlet (Master) Stage 1: Sending long text (132 bytes) ---
23:20:42 [   INFO] Received packet: Ack(conn_id=125, trans_id=1, frame_id=0)
23:20:49 [   INFO] PING: 5518ms
23:20:49 [   INFO] Received packet: Pong(conn_id=125, trans_id=1, remote_time=452873, local_delta=698)
23:21:06 [   INFO] Received packet: CTS(conn_id=125, trans_id=2, status=<CTSStatus.SEND_BULK: 0>, mod=<ModType.QPSK: 1>, speed=<CCSpeed.R12: 1>)
23:21:21 [   INFO] Received packet: Sack(conn_id=125, trans_id=184, frame_id=0, mask=3)
23:21:33 [   INFO] Received packet: RTS(conn_id=125, trans_id=2, frame_len=320, frames_count=3, data_type=<RTSDataType.COMPRESSED_TEXT: 1>)
23:21:41 [   INFO] Received packet: DataBytes(conn_id=125, frame_id=0, payload=b'\x87\xbfi\x85\x7f\n\xe1C\xf3\xe2\x17\xcdwQ^\xf3\xbe\x94vk\xe3\x8a\xae\x89/?+\x8a\xdfC\xec\x82\xb6\xa2\x94vk\xad\x91A')
23:21:47 [   INFO] Received packet: DataBytes(conn_id=125, frame_id=1, payload=b'\xd5\xbf\xdf\x85\xae\xfe|\xdc*\xf8Q\xd9\xaex\xbf\x8f\x84\x11\xdaazn8zT=\x9e\xd7k\xd2\xf5:j\xf0\xcb)\xd3\x91\xf6A')
23:21:52 [   INFO] Received packet: DataBytes(conn_id=125, frame_id=2, payload=b'\xd5,\xa8^\xd4>\xe1\xf6')
23:21:55 [   INFO] [Buffer Trace] Current buffer size: 139 bytes (Contains 'K': True)
23:21:55 [   INFO] >
=== RECEIVED FULL TEXT ===
What if it tempt you toward the flood, my lord? Or to the dreadful summit of the cliff That beetles o'er his base into the sea? Do not go!
=====================
23:21:55 [   INFO] --- Hamlet (Master) Stage 2: Sending text (147 bytes) ---
23:21:55 [   INFO] Received packet: Eot(conn_id=125, trans_id=174, reason_code=<EotReason.SUCCESS: 0>)
23:22:07 [   INFO] Received packet: CTS(conn_id=125, trans_id=3, status=<CTSStatus.REDUCE: 2>, mod=<ModType.QPSK: 1>, speed=<CCSpeed.R34: 3>)
23:22:13 [   INFO] Received packet: CTS(conn_id=125, trans_id=4, status=<CTSStatus.SEND_BULK: 0>, mod=<ModType.QAM16: 2>, speed=<CCSpeed.R12: 1>)
23:22:30 [   INFO] Received packet: Sack(conn_id=125, trans_id=242, frame_id=0, mask=7)
23:22:35 [   INFO] Received packet: RTS(conn_id=125, trans_id=3, frame_len=320, frames_count=2, data_type=<RTSDataType.COMPRESSED_TEXT: 1>)
23:22:41 [   INFO] Received packet: DataBytes(conn_id=125, frame_id=0, payload=b'\x87f\xbd\xe7\xf9\xe9t\xf5\xe1\xeea\xaf{\x8e\xca\xfc\xcf\xb5\xe4\xc5\xd6\x13A\x14\xbd\xfbL+\xd6\xbb\xb5\xef|p\xa3\xb5\xe9s^X')
23:22:45 [   INFO] Received packet: DataBytes(conn_id=125, frame_id=1, payload=b'\xfb \xd5yq\xda\xf3\xd9^\x96\xea!\xe2\xbcQ\xd9\xadD\xc3U\xf0\x83\xa7\x9eg\x7fd\xc9\x93\x0f\xb2')
23:22:48 [   INFO] [Buffer Trace] Current buffer size: 114 bytes (Contains 'K': True)
23:22:48 [   INFO] >
=== RECEIVED FULL TEXT ===
He waxes desperate with imagination. To what issue will this come? Something is rotten in the state of Denmark...
=====================
23:22:48 [   INFO] --- Hamlet (Master) Stage 3: Sending VERY long text (188 bytes) ---
23:22:48 [   INFO] Received packet: Eot(conn_id=125, trans_id=242, reason_code=<EotReason.SUCCESS: 0>)
23:23:06 [   INFO] Received packet: CTS(conn_id=125, trans_id=5, status=<CTSStatus.SEND_BULK: 0>, mod=<ModType.QAM16: 2>, speed=<CCSpeed.R12: 1>)
23:23:17 [   INFO] Received packet: Sack(conn_id=125, trans_id=181, frame_id=0, mask=1)
23:23:33 [   INFO] Received packet: RTS(conn_id=125, trans_id=4, frame_len=960, frames_count=1, data_type=<RTSDataType.COMPRESSED_TEXT: 1>)
23:23:41 [   INFO] Received packet: DataBytes(conn_id=125, frame_id=0, payload=b'\x85.\xa7\xe5Nt\xb2\xfd\xbbA%\xeb\xbc(\xedzW\xa5\xefY\xd6\xeb\xbe\x96\xa3s\x9e\xcc}\xd0Nt\xa3\xb3\xdb\xf8\xad\xb5:Rg\x82m{_\xd3W\x0b\xdd\xf1\xcdyd\xd0Gg\xb6\xa7my\xad\xb5\x1d\xaf=\xb4\xaf\x17g?O\x14\xe7I\xce\xe3\xb1$\x1d\xabs\x17D\x90Gi\xc5;k\xad\xb9\xf3\n\xbe\x15\xe2\xf9\xae\xfb^;_\x15\xaa\xf1\xdb\xe4\x9a\x0fjU\x83\xee\x1fe')
23:23:44 [   INFO] [Buffer Trace] Current buffer size: 190 bytes (Contains 'K': True)
23:23:44 [   INFO] >
=== RECEIVED FULL TEXT ===
O day and night, but this is wondrous strange! And therefore as a stranger give it welcome. There are more things in heaven and earth, Horatio, Than are dreamt of in your philosophy. Go on!
=====================
23:23:44 [   INFO] --- Hamlet (Master): Grand Dialogue Finished Successfully! ---
23:23:44 [   INFO] Received packet: Eot(conn_id=125, trans_id=53, reason_code=<EotReason.SUCCESS: 0>)
23:24:51 [   INFO] PING: 5548ms
23:24:51 [   INFO] Received packet: Pong(conn_id=125, trans_id=6, remote_time=694702, local_delta=681)
23:25:28 [   INFO] Finished.

23:20:32 [   INFO] Start client (R2HOR @ KO59DW)...
23:20:32 [   INFO] Connect to R1HAM
23:20:32 [   INFO] Found device: Monitor of Meteor Lake-P HD Audio Controller Speaker
23:20:32 [   INFO] Channels: 2
23:20:32 [   INFO] Init sound output...
23:20:32 [   INFO] Start semiduplex connection...
23:20:39 [   INFO] --- Horatio (Slave) Stage 1: Waiting for Hamlet's speech... ---
23:20:39 [   INFO] Setup connection mod=60, master_window=30, start_lag=30, tms_str='23:21:08'
23:20:39 [   INFO] Received packet: ConnAck(caller='R2HOR', called='R1HAM', caller_conn_id=185, called_conn_id=125, mod=60, master_window=30, start_lag=30)
23:20:45 [   INFO] Received packet: Ping(conn_id=125, trans_id=1, time=452873)
23:21:03 [   INFO] Received packet: RTS(conn_id=125, trans_id=2, frame_len=320, frames_count=2, data_type=<RTSDataType.COMPRESSED_TEXT: 1>)
23:21:10 [   INFO] Received packet: DataBytes(conn_id=125, frame_id=0, payload=b'\x84R\xf4\xc9*\xda\xca\x85\x063Gi\x85zQ\xd9\xaf\xce\xefQu\x83h=\xfb8\xec\xf6\x87\xb4^\x96W\xae\x1e\xd5\xe2\x8e\xcdy')
23:21:14 [   INFO] Received packet: DataBytes(conn_id=125, frame_id=1, payload=b'\xbc\xe9E-w\xf8\xf8{A\x1d\x9a\xd7\x17\x9e\xdaS\x9d)\xde\xeb\xdfJ\xbe\x15w\x8d\xcf\xb3\xae\xfa_\x15\xb8\xef\x8c\x992a\xf6')
23:21:18 [   INFO] [Buffer Trace] Current buffer size: 132 bytes (Contains 'K': True)
23:21:18 [   INFO] >
=== RECEIVED FULL TEXT ===
To be, or not to be, that is the question: Whether 'tis nobler in the mind to suffer The slings and arrows of outrageous fortune...
=====================
23:21:18 [   INFO] --- Horatio (Slave) Stage 1: Sending text (139 bytes) ---
23:21:18 [   INFO] Received packet: Eot(conn_id=125, trans_id=184, reason_code=<EotReason.SUCCESS: 0>)
23:21:36 [   INFO] Received packet: CTS(conn_id=125, trans_id=2, status=<CTSStatus.SEND_BULK: 0>, mod=<ModType.BPSK: 0>, speed=<CCSpeed.R12: 1>)
23:21:59 [   INFO] Received packet: Sack(conn_id=125, trans_id=174, frame_id=0, mask=7)
23:22:04 [   INFO] Received packet: RTS(conn_id=125, trans_id=3, frame_len=640, frames_count=2, data_type=<RTSDataType.COMPRESSED_TEXT: 1>)
23:22:10 [   INFO] Received packet: RTS(conn_id=125, trans_id=4, frame_len=320, frames_count=3, data_type=<RTSDataType.COMPRESSED_TEXT: 1>)
23:22:16 [   INFO] Received packet: DataBytes(conn_id=125, frame_id=0, payload=b'\x85\xc2\xf7\x9f\xa7\xa5\xe5\xadE\xf1\xc14\x1e\xd4\xab\t \xb1\xed\xc7\x0b\xe2\xb8\xe2\xbd\xd4vl}\xd0y\xf9_\x13\rs\xbbzU\xde')
23:22:20 [   INFO] Received packet: DataBytes(conn_id=125, frame_id=1, payload=b"\x14\xe7K\xcc\xfd\xbd'<\xf6^\x1cG\xca\x9d\xc3\xdf\xca\xbcQ\xda\xf4\xbdW_('K\xb4\xef\xaf\x95:Q\xd9\xa0\xc7\xe5\xce..")
23:22:24 [   INFO] Received packet: DataBytes(conn_id=125, frame_id=2, payload=b'\xb0{ic\xdf\xd3\x1fs\x1d\x84}\xc3\xec')
23:22:26 [   INFO] [Buffer Trace] Current buffer size: 147 bytes (Contains 'K': True)
23:22:26 [   INFO] >
=== RECEIVED FULL TEXT ===
It waves me still. Go on, I'll follow thee! My fate cries out and makes each petty artery in this body As hardy as the Nemean lion's nerve! Go on!
=====================
23:22:26 [   INFO] --- Horatio (Slave) Stage 2: Sending text (114 bytes) ---
23:22:26 [   INFO] Received packet: Eot(conn_id=125, trans_id=242, reason_code=<EotReason.SUCCESS: 0>)
23:22:38 [   INFO] Received packet: CTS(conn_id=125, trans_id=3, status=<CTSStatus.SEND_BULK: 0>, mod=<ModType.QAM16: 2>, speed=<CCSpeed.R12: 1>)
23:22:51 [   INFO] Received packet: Sack(conn_id=125, trans_id=242, frame_id=0, mask=3)
23:23:03 [   INFO] Received packet: RTS(conn_id=125, trans_id=5, frame_len=960, frames_count=1, data_type=<RTSDataType.COMPRESSED_TEXT: 1>)
23:23:10 [   INFO] Received packet: DataBytes(conn_id=125, frame_id=0, payload=b"\x85\xa9\xf2\xa3\xb7\xca\xf8\x98\xec\xf6=\xb4\xb5\xe2\xf7pI\x07U^G\xb7K\xe2\xb6\xa5r\xf7\x13x\xa1\xef\xca\x8a^\xf3\xc7\xda\x8e\xcde\xfbv\x82H'\x0cq(\xec\xd7S\xf2\xb9\xac\xf8\xbc\x1e\xdd(\xa5\xf1:\x85x\xbe/oD\x90E\xf1\xc2\x8e\xcd|W~\x17;\xbf/K\xaa\xc6\xaf\x17\x9f\x95\xd4\xfc\xe9W\xc2\xc9\x8e\xfbh'mz\xef\xbc\x859\xd2\xf1\xdf~\xc3\xdb\xa5>\xf3\xf2L>\xcb")
23:23:14 [   INFO] [Buffer Trace] Current buffer size: 188 bytes (Contains 'K': True)
23:23:14 [   INFO] >
=== RECEIVED FULL TEXT ===
I am thy father's spirit, Doom'd for a certain term to walk the night, And for the day confin'd to fast in fires, Till the foul crimes done in my days of nature Are burnt and purg'd away.
=====================
23:23:14 [   INFO] --- Horatio (Slave) Stage 3: Sending final long text (190 bytes) ---
23:23:14 [   INFO] Received packet: Eot(conn_id=125, trans_id=181, reason_code=<EotReason.SUCCESS: 0>)
23:23:36 [   INFO] Received packet: CTS(conn_id=125, trans_id=4, status=<CTSStatus.SEND_BULK: 0>, mod=<ModType.QAM16: 2>, speed=<CCSpeed.R12: 1>)
23:23:47 [   INFO] Received packet: Sack(conn_id=125, trans_id=53, frame_id=0, mask=1)
23:24:47 [   INFO] Received packet: Ping(conn_id=125, trans_id=6, time=694702)
23:25:27 [   INFO] Finished.

В качестве полезной нагрузки в обмене сообщениями использовался сокращенный диалог между Гамлетом (R1HAM) и Горацио (R2HOR). Логика взаимодействия была организована в формате диалога: после принятия сообщения узел автоматически переходил в режим отправки своей следующей реплики.

В логах можно заметить CTS пакеты с модуляциями QPSK и QAM16, а также изменением скорости кодера до ¾.

Для комплексной проверки использовалось сжатие текста. Записи "RECEIVED FULL TEXT" подтверждают правильность конкатенации принятых блоков данных и их декомпрессию в человеко читаемый текст.

Вывод строки "Hamlet (Master): Grand Dialogue Finished Successfully!" подтверждает полную передачу информационного массива и успешное завершение сеанса связи. После этого сессия перешла в состояние удержания соединения Keep-Alive, в котором циклически отправляются Ping-запросы для предотвращения преждевременного разрыва соединения.

Тестирование

Помимо синтетических тестов, показывающих работоспособность скриптов для передачи пакетов в полудуплексном режиме, был разработан графический интерфейс, предоставляющий возможность отслеживать маяки, устанавливать с ними соединение и обмениваться сообщениями.

Обмен данными производился через loopback звуковой карты.

Гамлет выступал в качестве ведущего узла. Его задача заключалась в посылке CQ-сигнала (рисунок 22) и, после установления соединения, передаче знаменитого монолога (рисунок 23).

Также необходимо отметить, что из-за особенностей работы звуковой карты, часто возникала ситуация, когда созвездия сильно искажались (рисунок 25). Механизмы когерентного накопления и эквализации восстанавливают созвездия до приемлемого состояния, а сверточный код позволяет восстановить данные при уровнях BER порядка 5-7%.

Примечание:
Помимо деградации сигнального созвездия, также наблюдался эффект его разворота (примерно на 10 градусов против часовой стрелки). 

Причина возникновения такого эффекта долго была не понятна. Были перепроверены эквалайзер, синхронизация (здесь стоит отметить, что сдвиг на 3 семпла делал демодуляцию невозможной, а при сдвиге на 2 семпла поворот был близок к 90 градусам; примечание к тезису о необходимости использования ZC-последовательностей), тайлинг OFDM-символов, и прочей цепочки вычислений. Де-факто, подменив данные звуковой карты на сигнал из wav файла, проблема исчезла, что в итоге оставило единственного подозреваемого — звуковую карту. 

После настройки параметров ALSA проблема с разворачивание созвездий пропала.

После того как монолог Гамлета был полностью принят (рисунок 26), из интерфейса было отправлено встречное сообщение (рисунок 30), которое было зафиксировано в логах ведущего узла:

18:53:33 [   INFO] Received packet: RTS(conn_id=235, trans_id=2, frame_len=320, frames_count=1, data_type=<RTSDataType.COMPRESSED_TEXT: 1>)
18:53:39 [   INFO] Received packet: DataBytes(conn_id=235, frame_id=0, payload=b'\x86\xca\x80>\x01\x87q\xb4\x1b\xafg\xb5\xba\xf6{&\x82\xbe\x9e\xc9\x97')
18:53:43 [   INFO]
=== RECEIVED FULL TEXT ===
R9FEU: Roger roger. Over.
=====================
18:53:43 [   INFO] Received packet: Eot(conn_id=235, trans_id=86, reason_code=<EotReason.SUCCESS: 0>)

Примечание:
Отметки времени на рисунке 27 и логах не совпадают, так как изначально автор забыл своевременно сделать скриншот.

Тестирование в симуляции эфира

Испытания в условиях, приближенных к реальному радиоэфиру, выполнялись с помощью симулятора каналов связи. Он формировал широкополосный квадратурный (IQ) сигнал, в котором исходящий поток модема подвергался однополосной амплитудной модуляции с верхней боковой полосой (USB).

Код модулятора:

import numpy as np
from scipy.signal import resample_poly
from scipy.io.wavfile import write, read
from scipy.signal import hilbert


def mod_DSB(time, freq_carrier, mod_signal):
    carrier = np.exp(1j * 2 * np.pi * freq_carrier * time)
    envelope = mod_signal
    return envelope * carrier


def mod_USB(time, freq_carrier, mod_signal):
    envelope = hilbert(mod_signal)
    return mod_DSB(time, freq_carrier, envelope)
...

Функция mod_DSB реализует двухполосную амплитудную модуляцию с подавленной несущей (DSB-SC). Комплексная огибающая формируемого сигнала вычисляется путем применения преобразования Гильберта к исходному дискретному сигналу.

...
def rand(shape):
    return np.random.normal(0, 1, size=shape)

fs = int(1e6)
...

Функция rand генерирует отсчеты аддитивного белого гауссова шума. Частота дискретизации сигнала задана равной 1.0 МГц.

...
src_sr, src_data = read("/tmp/ofdm-signal-src.wav")
duration = len(src_data) / src_sr

payload = resample_poly(src_data / 32768, fs, src_sr)

time = np.arange(fs * duration) / fs
usb_signal = mod_USB(time, 50000, payload)
...

Частота несущей USB-сигнала задана равной 50.0 кГц.

...
amp = 1.0
iq_signal = usb_signal * amp
iq_signal /= np.max(np.abs(iq_signal))

snr_db = 6.0
p_signal = np.mean(np.abs(iq_signal) ** 2)
p_noise = p_signal / (10 ** (snr_db / 10))
...

Отношение сигнал/шум установлено на уровне 6дБ (слабый, едва заметный шум).

...
noise = (rand(iq_signal.shape) + 1j * rand(iq_signal.shape)) * np.sqrt(p_noise / 2)

iq_signal = iq_signal + noise
...

Выполняется аддитивное смешивание квадратурного сигнала с шумовой составляющей.

...
iq_output = np.vstack((iq_signal.real, iq_signal.imag)).T
write("/tmp/ofdm-sdr-iq.wav", fs, (iq_output * 32767).astype(np.int16))

На рисунке 28 приведен результат воспроизведения IQ-сигнала в программе sdrpp.

На рисунке 29 приведен результат демодуляции снифером сигнала, воспроизводимого программой sdrpp.

Так как в sdrpp невозможно отключить AGC, для корректного восстановления информационного сигнала из квадратурного потока был реализован собственный демодулятор:

import numpy as np
from scipy.signal import resample_poly, butter, lfilter
from scipy.io.wavfile import write, read


def lowpass_filter(s, cutoff, fs):
    nyq = 0.5 * fs
    normal_cutoff = cutoff / nyq
    b, a = butter(5, normal_cutoff, btype='low')
    return lfilter(b, a, s)
...

Для подавления внеполосных излучений при демодуляции USB-сигнала применяется фильтр нижних частот Баттерворта. Параметр nyq задает частоту Найквиста, равную половине частоты дискретизации исходного сигнала.

...
def demod_USB(fs, fc, s, sr):
    t = np.arange(len(s)) / fs
    shifted = s * np.exp(-2j * np.pi * fc * t)

    filtered = lowpass_filter(shifted, sr * 0.5, fs)
    signal = resample_poly(filtered, sr, fs)
    return np.real(signal)
...

Алгоритм работы комплексного USB-демодулятора: умножение на комплексную экспоненту осуществляет перенос спектра сигнала из высокочастотной области в базовую полосу (процесс цифрового гетеродинирования). Последующая фильтрация с помощью ФНЧ подавляет спектральные составляющие, лежащие за пределами полосы пропускания полезного сигнала.

Функция resample_poly выполняет даунсемплинг сигнала до целевой частоты дискретизации.

...
fs, data = read("/tmp/ofdm-sdr-iq.wav")
data = data / 32768.0
iq_signal = data[:, 0] + 1j * data[:, 1]

fc_target = 50000
audio = demod_USB(fs, fc_target, iq_signal, 12000)

write("/tmp/out.wav", 12000, (audio * 32767).astype(np.int16))

Переменная fc_target определяет частоту несущей, задействованной при модуляции USB-сигнала. Частота дискретизации выходного потока составляет 12.0 кГц.

Таким образом, на Python/numpy реализуется простейший SDR приемник.

На рисунке 30 приведены результаты анализа демодулированного сигнала.

Примечание:
Можно обратить внимание на качественное отличие в показаниях столбца SNR. Эффект связан с тем, что при воспроизведении сигнала была существенно снижена его амплитуда. То есть достаточно громкий сигнал приводит к фазовым искажениям сигнала и деградации сигнального созвездия (рисунок 34). Также, при высоких значениях амплитуды кривая АЧХ канала вышла за габариты графика.

Тестирование в эфире

Как и в предыдущей статье, тест осуществлялся с применением УКВ трансивера ICOM IC-9700 и SDR-приемника RX-888 под управлением SDR Console.

Перечень пакетов, сформированных в рамках тестирования на звуковой карте, был записан в один wav-файл, воспроизведенный на машине, подключенной к трансиверу. 

В программе SDR Console эфир записывался в файл с IQ данными. При записи использовалась частота дискретизации в 1.0 МГц.

Демодулированный из полученного файла сигнал отправлялся на вход сниффера для оценки качества демодуляции.

В качестве эксперимента была использована программа sdrpp для динамического воспроизведения сигнала из IQ потока (рисунок 32).

На рисунке 33 приведены результаты демодуляции пакетов, что подтверждает возможность применения такого средства связи на практике. Тем не менее, применение звуковых трактов для передачи сигнала, оказывает очень сильное разрушающее воздействие на сигнал, хоть при этом математика DSP и позволяет нивелировать эти эффекты.

Заключение

В статье были рассмотрены механизмы реализации MAC и LLC уровней в самодельном, радиолюбительском протоколе на базе OFDM. На PHY-уровне были интегрированы новые схемы модуляций, оптимизирована частотная сетка ортогональных поднесущих, модернизирован эквалайзер. Подробно описана реализация алгоритмов установления связи, ведения сессии, динамического регулирования скорости, а также приведены результаты верификации системы как в условиях симуляции, так и при испытаниях в реальном радиоэфире.

В процессе проектирования архитектуры стека протоколов во многом были воспроизведены базовые технологические этапы, характерные для эволюции стандартов беспроводной связи Wi-Fi и 5G.

В статью не вошли 32-QAM модуляция и обмен RSSI между удаленными узлами.

Subscribed it, gave't the impression, placed it safely. Now, the next day was our sea-fight.