DQPSK и QPSK при неизвестной фазе и сдвиге частоты
DQPSK и QPSK при неизвестной фазе и сдвиге частоты
В примере сравниваются два способа передать два бита на символ, когда фаза и частота несущей в приёмнике неизвестны. Когерентная QPSK требует точного знания фазы, дифференциальная DQPSK кодирует информацию в разности фаз соседних символов и обходится без этого. Сигналы формируются, искажаются и демодулируются системными объектами EngeeComms, а для когерентного приёмника строится оценка сдвига частоты по методу четвёртой степени с развёрткой фазы объектом Unwrap из EngeeDSP. Скрипт показывает созвездия, помехоустойчивость по сравнению с теорией и допустимый сдвиг частоты для каждого приёмника. Пример полезен разработчикам простых радиомодемов, которые выбирают между дифференциальной модуляцией и схемой синхронизации несущей.
Приёмник получает комплексную огибающую с неизвестными начальной фазой и сдвигом частоты :
где — длительность символа, — белый гауссов шум.
QPSK передаёт биты значением фазы символа. Если приёмник не знает и , созвездие поворачивается, и после поворота больше чем на решения становятся неверными. Поэтому когерентный приёмник должен оценить и скомпенсировать фазу и частоту.
DQPSK передаёт биты приращением фазы между соседними символами. Приёмник вычисляет , и неизвестная фаза сокращается. Сдвиг частоты оставляет постоянную ошибку на символ, и пока она меньше , решения верны. В примере используется вариант -DQPSK, принятый в EngeeComms по умолчанию.
За устойчивость DQPSK платит помехоустойчивостью: в разности фаз участвуют два зашумлённых символа. Вероятность битовой ошибки для QPSK и -DQPSK с кодом Грея при отношении :
где — функция Маркума, — модифицированная функция Бесселя.
Для символов QPSK четвёртая степень снимает модуляцию: постоянна. В EngeeComms точки QPSK лежат на углах , поэтому , и приёмник умножает на . Фаза растёт линейно со скоростью на символ. Приёмник усредняет по блокам из символов, чтобы подавить шум, развёртывает фазу блоков объектом Unwrap и находит наклон и смещение прямой методом наименьших квадратов. Деление на даёт оценки и с неоднозначностью , которую снимают несколько известных пилотных символов в начале кадра.
Развёртка корректна, пока приращение фазы между блоками меньше , то есть . При и мкс это кГц.
Подключим библиотеки и задайте параметры. Символьная скорость Мсимвол/с, кадр — символов. Канал вносит начальную фазу и сдвиг частоты кГц, что даёт поворот на за кадр.
using EngeeComms, EngeeDSP, Plots, Printf, Random, Statistics, SpecialFunctions
gr()
Ts = 1e-6 # длительность символа, с
N = 20_000 # символов в кадре
phase0 = 30.0 # начальная фаза канала, град
cfo = 1000.0 # сдвиг частоты, Гц
K = 32 # символов в блоке оценки частоты
n_pilot = 16 # пилотных символов для снятия неоднозначности 90°
Random.seed!(2024)
sym = rand(0:3, N)
bits_of(s) = vcat([[(v >> 1) & 1, v & 1] for v in s]...)
qpsk_tx = EngeeComms.QPSKBasebandModulator()(sym)
dqpsk_tx = EngeeComms.DQPSK_ModulatorBaseband()(sym)
@printf("Поворот фазы за кадр: %.0f град, за символ: %.3f град\n", 360cfo * N * Ts, 360cfo * Ts)
Функция channel применяет к сигналу сдвиг фазы и частоты объектом PhaseFrequencyOffset и добавляет шум объектом AWGN. Объект PhaseFrequencyOffset задаёт шаг дискретизации через длительность кадра FramePeriod, поэтому она равна . Объект AWGN повторяет одну и ту же реализацию шума для одинакового InitialSeed, поэтому начальное значение передаётся явно.
function channel(tx, ebno_db; phase = phase0, fo = cfo, seed = 1)
shifted = EngeeComms.PhaseFrequencyOffset(PhaseOffset = phase, FrequencyOffset = fo,
FramePeriod = length(tx) * Ts)(tx)
isinf(ebno_db) && return shifted
vec(EngeeComms.AWGN(EbNo = ebno_db, BitsPerSymbol = 2, InitialSeed = seed)(shifted))
end
rx_q = channel(qpsk_tx, 10.0)
rx_d = channel(dqpsk_tx, 10.0)
println("Длина принятых кадров: ", length(rx_q), ", ", length(rx_d))
Реализуем оценку частоты и фазы. Объект Unwrap из EngeeDSP устраняет скачки фазы на между соседними блоками. После компенсации пилотные символы определяют, на какой из четырёх углов нужно довернуть созвездие.
function estimate_offset(r, pilots_tx)
nb = length(r) ÷ K
# Символы QPSK лежат на углах π/4 + kπ/2, поэтому s⁴ = −1: знак минус снимает модуляцию
z = [-sum(r[(i-1)*K+1:i*K] .^ 4) for i in 1:nb] # усреднённая четвёртая степень
ph = vec(EngeeDSP.Unwrap()(angle.(z))) # развёрнутая фаза блоков
tc = ((1:nb) .- 0.5) .* K .- 0.5 # центры блоков, в символах
slope = sum((tc .- mean(tc)) .* (ph .- mean(ph))) / sum((tc .- mean(tc)) .^ 2)
fo_hat = slope / (4 * 2π * Ts)
phi4 = mean(ph) - slope * mean(tc) # фаза r^4 в момент n = 0
corr = r .* cis.(-(slope .* (0:length(r)-1) .+ phi4) ./ 4)
# Неоднозначность 90°: доворот, лучше всего совпадающий с пилотами
k_best = argmax([real(sum(corr[1:n_pilot] .* cis(k * π / 2) .* conj.(pilots_tx))) for k in 0:3])
(; fo_hat, corr = corr .* cis((k_best - 1) * π / 2), ph, tc)
end
est = estimate_offset(rx_q, qpsk_tx[1:n_pilot])
@printf("Оценка сдвига частоты: %.1f Гц (истинный %.1f Гц)\n", est.fo_hat, cfo)
По кадру из символов при дБ оценка сдвига частоты равна Гц при истинном значении Гц. Ошибка Гц даёт набег фазы всего за весь кадр.
Сравним созвездия при дБ. Для DQPSK показано произведение , по которому принимает решение дифференциальный демодулятор. EVM рассчитывается объектом EVM из EngeeComms.
dc02_evm_measure = EngeeComms.EVM()
diff_d = rx_d[2:end] .* conj.(rx_d[1:end-1])
diff_ref = dqpsk_tx[2:end] .* conj.(dqpsk_tx[1:end-1])
evm_raw = dc02_evm_measure(qpsk_tx, rx_q)
evm_corr = EngeeComms.EVM()(qpsk_tx, est.corr)
evm_diff = EngeeComms.EVM()(diff_ref, diff_d ./ sqrt(mean(abs2, diff_d)))
@printf("EVM: QPSK без коррекции %.1f %%, QPSK с оценкой %.1f %%, DQPSK (разность фаз) %.1f %%\n",
evm_raw, evm_corr, evm_diff)
function plot_constellation(z, title_text)
idx = 1:5:length(z)
scatter(real.(z[idx]), imag.(z[idx]); ms = 1.5, alpha = 0.35, markerstrokewidth = 0, label = "",
aspect_ratio = 1, xlims = (-1.8, 1.8), ylims = (-1.8, 1.8), xlabel = "I", ylabel = "Q",
title = title_text, titlefontsize = 10)
end
plot(plot_constellation(rx_q, @sprintf("QPSK без коррекции\nEVM = %.0f %%", evm_raw)),
plot_constellation(est.corr, @sprintf("QPSK с оценкой частоты\nEVM = %.1f %%", evm_corr)),
plot_constellation(diff_d ./ sqrt(mean(abs2, diff_d)), @sprintf("DQPSK: r(n)·r*(n-1)\nEVM = %.1f %%", evm_diff));
layout = (1, 3), size = (1050, 380), left_margin = 4Plots.mm, bottom_margin = 5Plots.mm)
Без коррекции созвездие QPSK размазано в кольцо: за кадр оно поворачивается на , и EVM превышает . После оценки частоты и фазы четыре облака точек вернулись на свои места, EVM определяется только шумом.
Для DQPSK разность фаз соседних символов тоже образует четыре облака без всякой синхронизации. Облака шире, EVM : в произведении участвует шум двух символов.
Рассчитаем вероятность битовой ошибки для от до дБ для четырёх приёмников: QPSK без сдвигов канала (идеальная синхронизация), QPSK с оценкой частоты, QPSK без коррекции и DQPSK. Для каждой точки используется своё начальное значение шума.
ebnos = collect(0.0:1.0:12.0)
tx_bits = bits_of(sym)
ber(rx_sym; skip = 0) = count(bits_of(rx_sym)[2skip+1:end] .!= tx_bits[2skip+1:end]) / (length(tx_bits) - 2skip)
curves = Dict(k => Float64[] for k in ("ideal", "est", "raw", "dqpsk"))
for (i, eb) in enumerate(ebnos)
push!(curves["ideal"], ber(EngeeComms.QPSKBasebandDemodulator()(channel(qpsk_tx, eb; phase = 0.0, fo = 0.0, seed = 10i))))
r = channel(qpsk_tx, eb; seed = 10i + 1)
push!(curves["raw"], ber(EngeeComms.QPSKBasebandDemodulator()(r)))
push!(curves["est"], ber(EngeeComms.QPSKBasebandDemodulator()(estimate_offset(r, qpsk_tx[1:n_pilot]).corr); skip = n_pilot))
push!(curves["dqpsk"], ber(EngeeComms.DQPSK_DemodulatorBaseband()(channel(dqpsk_tx, eb; seed = 10i + 2)); skip = 1))
end
Qf(x) = 0.5erfc(x / sqrt(2))
function marcum_q1(a, b)
x = range(b, b + a + 40; length = 20_000)
f = x .* exp.(-(x .- a) .^ 2 ./ 2) .* besselix.(0, a .* x)
step(x) * (sum(f) - (f[1] + f[end]) / 2)
end
function ber_dqpsk(γ)
a = sqrt(2γ * (1 - 1 / sqrt(2))); b = sqrt(2γ * (1 + 1 / sqrt(2)))
marcum_q1(a, b) - 0.5 * besselix(0, a * b) * exp(-(a - b)^2 / 2)
end
γs = 10 .^ (range(0, 12; length = 200) ./ 10)
th_qpsk = Qf.(sqrt.(2γs)); th_dqpsk = ber_dqpsk.(γs)
println(rpad("Eb/No, дБ", 11), rpad("идеальная", 12), rpad("с оценкой", 12), rpad("без корр.", 12), "DQPSK")
for (i, eb) in enumerate(ebnos)
println(rpad(@sprintf("%.0f", eb), 11), rpad(@sprintf("%.2e", curves["ideal"][i]), 12),
rpad(@sprintf("%.2e", curves["est"][i]), 12), rpad(@sprintf("%.2e", curves["raw"][i]), 12),
@sprintf("%.2e", curves["dqpsk"][i]))
end
Построим кривые помехоустойчивости вместе с теоретическими.
floor_ber(v) = max.(v, 1e-5)
pb = plot(range(0, 12; length = 200), th_qpsk; lw = 1.5, ls = :dash, color = :royalblue, label = "теория QPSK",
yscale = :log10, ylims = (1e-5, 1), xlabel = "Eb/N0, дБ", ylabel = "Вероятность битовой ошибки",
title = "QPSK и DQPSK при начальной фазе 30° и сдвиге частоты 1 кГц", legend = :bottomleft,
size = (1000, 460), left_margin = 5Plots.mm, bottom_margin = 5Plots.mm)
plot!(pb, range(0, 12; length = 200), th_dqpsk; lw = 1.5, ls = :dash, color = :darkorange, label = "теория π/4-DQPSK")
scatter!(pb, ebnos, floor_ber(curves["ideal"]); color = :royalblue, marker = :circle, label = "QPSK, идеальная синхронизация")
scatter!(pb, ebnos, floor_ber(curves["est"]); color = :seagreen, marker = :diamond, label = "QPSK с оценкой частоты")
scatter!(pb, ebnos, floor_ber(curves["dqpsk"]); color = :darkorange, marker = :square, label = "DQPSK")
scatter!(pb, ebnos, floor_ber(curves["raw"]); color = :gray, marker = :xcross, label = "QPSK без коррекции")
pb
Измеренные точки совпадают с теоретическими кривыми:
- QPSK с оценкой частоты повторяет QPSK с идеальной синхронизацией начиная с дБ. При – дБ шум срывает развёртку фазы или разрешение неоднозначности по пилотам, и приёмник теряет кадр целиком.
- DQPSK проигрывает когерентной QPSK около дБ: вероятность достигается при дБ вместо дБ.
- QPSK без коррекции непригодна при любом отношении сигнал/шум: вероятность ошибки .
Точки QPSK при дБ показаны на нижней границе графика: на битах ни одной ошибки не произошло.
Увеличивайте сдвиг частоты от до кГц (нулевой сдвиг на графике показан в точке кГц), то есть до символьной скорости, при дБ. DQPSK должна работать, пока набег фазы за символ меньше , то есть до кГц. Когерентный приёмник с оценкой частоты ограничен условием развёртки кГц.
cfos = [0, 1, 2, 3, 4, 5, 8, 15, 30, 60, 90, 110, 125, 140, 150] .* 1e3
ber_d_cfo = Float64[]; ber_e_cfo = Float64[]
for (i, fo) in enumerate(cfos)
push!(ber_d_cfo, ber(EngeeComms.DQPSK_DemodulatorBaseband()(channel(dqpsk_tx, 10.0; fo = fo, seed = 500 + i)); skip = 1))
r = channel(qpsk_tx, 10.0; fo = fo, seed = 600 + i)
push!(ber_e_cfo, ber(EngeeComms.QPSKBasebandDemodulator()(estimate_offset(r, qpsk_tx[1:n_pilot]).corr); skip = n_pilot))
end
fo_plot = max.(cfos, 500) ./ 1e3 # нулевой сдвиг показан в точке 0.5 кГц
pc = plot(fo_plot, floor_ber(ber_d_cfo); marker = :square, lw = 2, color = :darkorange, label = "DQPSK",
yscale = :log10, ylims = (1e-5, 1), xscale = :log10, xlims = (0.4, 170), xticks = ([1, 2, 5, 10, 20, 50, 100, 150], string.([1, 2, 5, 10, 20, 50, 100, 150])),
xlabel = "Сдвиг частоты, кГц", ylabel = "Вероятность битовой ошибки",
title = "Устойчивость к сдвигу частоты при Eb/N0 = 10 дБ", legend = :topleft,
size = (1000, 430), left_margin = 5Plots.mm, bottom_margin = 5Plots.mm)
plot!(pc, fo_plot, floor_ber(ber_e_cfo); marker = :diamond, lw = 2, color = :seagreen, label = "QPSK с оценкой частоты")
vline!(pc, [1 / (8K * Ts) / 1e3]; ls = :dot, color = :seagreen, label = "предел развёртки 3.9 кГц")
vline!(pc, [125]; ls = :dot, color = :darkorange, label = "предел DQPSK 125 кГц")
for (fo, bd, be) in zip(cfos, ber_d_cfo, ber_e_cfo)
@printf("Δf = %6.0f Гц: DQPSK %.2e, QPSK с оценкой %.2e\n", fo, bd, be)
end
pc
Два приёмника ведут себя принципиально по-разному:
- QPSK с оценкой частоты работает без ошибок до кГц и полностью отказывает уже при кГц, как только нарушается условие развёртки кГц. Расширить диапазон можно, уменьшив размер блока , но тогда усреднение хуже подавляет шум.
- DQPSK деградирует плавно. До кГц, то есть на символ, вероятность ошибки растёт в – раза. При кГц она увеличивается почти в раз, а при кГц, когда набег фазы достигает , достигает .
Сдвиг частоты – кГц соответствует точности кварцевого генератора – ppm на частоте ГГц. Для таких условий DQPSK работает без какой-либо синхронизации, а когерентной QPSK нужна предварительная грубая оценка частоты.
string("DC02 ok; Eb/No=10 dB: QPSK ideal=", round(curves["ideal"][11], sigdigits = 3), " est=", round(curves["est"][11], sigdigits = 3),
" DQPSK=", round(curves["dqpsk"][11], sigdigits = 3))
Вывод
Пример сравнил два подхода к неизвестной фазе и частоте несущей на системных объектах EngeeComms и EngeeDSP.
- Когерентная QPSK с оценкой частоты методом четвёртой степени и развёрткой фазы объектом
Unwrapдостигает теоретической помехоустойчивости QPSK начиная с дБ. Но она работает только в узком диапазоне сдвигов частоты, до кГц при выбранном размере блока, и требует пилотных символов. - DQPSK обходится без синхронизации несущей, выдерживает сдвиг частоты в десятки килогерц и проигрывает в помехоустойчивости около дБ, в полном соответствии с теорией.
Выбор определяется бюджетом линии связи. Если запас по мощности есть, DQPSK проще и надёжнее при нестабильных генераторах. Если важен каждый децибел, нужна когерентная схема с многоступенчатой синхронизацией: грубая оценка частоты, затем точная, затем слежение за фазой.


