Hi Leonhard,
a really short reply because I'm stuck with a lot of other things, but:
256-QAM is indeed not trivial to phase synchronize, and you're right - your
usual Costas
loop will have a hard time! Remember that the Costas loop tries to "lock onto"
the limited
amount of phases that exist in the "correct" constellation. For BPSK, QPSK,
that's simple.
For 256-QAM, there's 32 constellation points in each of the eight symmetric (0,
pi/4],
(pi/4, pi/2]... sectors... you end up with 192 different phases (python code
[1]).
Now, there's still some *adaptive blind phase estimation* algorithms that you
could look
into, but in all honesty: Things are hard!
You typically go for some data/preamble-aided method with higher-order QAMs:
For example,
just send a known preamble, and correlate against that. If you send the same
L-length
preamble twice with a known distance D between their beginnings (often, just
one right
after the first), you can employ a fixed-lag correlation (i.e. just a
dot-product between
a vector of L samples with another vector of L samples, taken D later). The
phase of that
will depend on how much the phase of the second preamble has rotated compared
to the first
– and a phase rotation that always happens over a fixed time, that's a
frequency, so you
got your frequency estimation done that way.
>From the correlation of the received preamble with the known transmit
>preamble, you get an
absolute phase.
Note that in wireless communications, there's not that many cases where you
have 256-QAM,
but not some external structure that needs synchronization, anyway. Most
commonly (LTE,
WiFi, DTV, DSL, …) you'll find QAM within OFDM – and for OFDM, there's clever
synchronization. Schmidl&Cox is an all-time favorite ;)
Cheers,
Marcus
[1]
#!/usr/bin/env python
from fractions import Fraction as ratio
import itertools
# Number of bits in QAM, N = 8 -> 256-QAM
N = 8
# make the inphase points; sqrt(2**N) of them, centered on 0, spaced 2
inphase_component = range(-(2**(N//2))+1, 2**(N//2), 2)
#Make all combinations of inphase and quadrature components.
const_points = itertools.product(inphase_component, inphase_component)
# Fraction "auto-cancels",
# so that we get a deduplicated set of slopes, equivalent to angles
# Notice that {...} is Python's way of building a set from a generator
slopes = { ratio(*point) for point in const_points }
# Need to double the length, because (-3/-2) = (3/2), but these have
# different phases
print(f"Number of different angles in {2**N}-QAM: {2 * len(slopes)}")
On 20.09.21 09:10, Röpfl, Leonhard wrote:
> Dear GNU Radio Community,
>
>
> since a couple of months i try to get a 256-QAM Transmission over Air to work.
>
>
> Now i reached a dead point, because i could not get the receiver locked on
> the phase of
> the QAM.
>
>
> 4-QAM is not a Problem, it works fine like it is described in the Tutorial.
>
>
> I have tried Polyphase Clock Sync, Costas Loop ect. (what ever i found under
> Synchronizers) in quite various combination,
>
> but this leads to nothing.
>
>
> My guess is that Costas Loop is not working for higher QAM anyway.
>
>
> I did not find any description, how this could be done right, neither in the
> Internet (Google, Youtube) nor in the library of our
>
> University.
>
>
> Helpful would be:
>
>
> - a generic description or example how this is done
>
>
> - a reference one a book or paper which describe that (even if this book is
> expensive)
>
>
> - link to an online-resource
>
>
> Thanks in advance
>
>
> Best regards
>
>
> Leonhard
>
>
>
>
>
>
