2
$\begingroup$

I've worked through a number of PSK demodulation tutorials, but they all start with a single PSK signal that fills the entire sample rate.

But what if the signal is in the real world? What kind of filter would I use to isolate the particular signal of interest? I guess something that preserves the root-raised-cosine pulse shape, so what would that be, and how do I know what the minimum passband width is?

$\endgroup$
  • $\begingroup$ You could use the same RRC filter that was used in the transmitter. $\endgroup$ – John Aug 17 '16 at 13:21
1
$\begingroup$

I think this should be seen in context with Phil's other, excellent, question:

How can I perform timing recovery from the envelope of PSK signals?

where the situation is the following:

There's 15 equidistant PSK subcarriers, and the center one carries a synchronization sequence, continously.

Channelization, as approached by Phil (and how I'd recommend, too) was done with a polyphase filterbank. Now, synchronization becomes a bit tricky: If using the pulse shape filter in the filter bank, then a lot of the info that a polyphase filterbank synchronizer could use to reconstruct timing information is lost.

So my immediate reaction was: well, then don't use the RRC filter in the filterbank, but use something that passes the whole RRC spectral shape nearly unharmed, thus has a pretty wide passband and pretty steep transition band. Technically, that would've posed no problem – PFBs are very efficient, and the sampling rates were very low.

So, thinking about this, it becomes a Chicken/Egg problem:

  • If you wanted to use such a "sharp" pre-filter, you'd need to make sure that the RRC-shaped signal is pretty much in the center of it, which requires frequency sync. If it's not centered, you'll cut off substantial parts of the signal's energy and/or introduce adjacent channel interference
  • Frequency sync is the whole reason we want to do this in the first place.

So, maybe, my idea wasn't that sharp to begin with.


However, this question is a good one, because

  1. it showed that my ideas aren't always the best ones and
  2. this question goes a whole lot farther:

Dropping knowledge of the original signal bandwidth, timing, and spectral location, this becomes a very interesting estimation problem.

So, not to scare you, but: demodulation, compared to sync, is typically the easier part. That's the reason why, for example, the GNU Radio tutorials kind of avoid going deep into that topic. Synchronization often happens by employing specially crafted data in the transmission, or is interwoven with equalization, and hence often very application-specific.

But: Of course there are re-usable, standard, known-to-work-well methods.

Often, one starts by looking at this whole problem to be solved by a combination of three mechanisms:

  1. Rough frequency estimation/correction
  2. Carrier Phase / fine frequency estimation/correction
  3. Timing Recovery

But you have an additional problem: you don't know the analog bandwidth of your signal, meaning that you either don't know the parameters of your pulse shaping filter, or the symbol rate. (We'll leave out Doppler spread for now)

Let us assume we know, however, that we've got to deal with PSK, and that we at least know the number of carriers.

Rough Frequency Correction

A classical approach, if knowing that we only have one carrier in a given bandwidth, would be a band-edgel FLL; simply put: let's have two overlapping band pass filters. If the upper one sees more power than the lower one, the signal isn't centered, increase the correction frequency, otherwise reduce it.

Statistically, this would work with multiple carriers, too; doesn't really matter whether the energy comes from a single carrier, or from 15 that are equidistant in frequency. Now, sadly, in fact, this doesn't work, usually, because one of the main reasons for using multiple subcarriers instead of just one broader channel is that you can then equalize them more easily isolatedly; so you do that in a situation where the channel's attenuation typically isn't flat, and hence, the whole "power equilibrium" hypothesis breaks down.

But, not all is lost: Band-edge FLL, whilst being a standard technology in analog receivers, isn't the only way to determine/correct position of carriers. We now enter the world of frequency estimators, or, given that we know some parameters of the transmission, but not others, parametric frequency estimation.

For example, a simple method would be to look for peaks in the averaged spectrum as given by a DFT of sufficient resolution. Another method would be employing something like ESPRIT, since we know the number of spectral peaks we're expecting.

Given that we now would now the position and spacing of the carriers:

Bandwidth and Pulse Shape Parameter Estimation

This is a pretty interesting problem; with the carrier spacing and position from the previous problem, we can now at least partially isolate one carrier. Assuming sufficiently high SNR, a variance estimate can be used to determine RRC roll-off. Note that this is really the case where you'd need a filter with a flat passband and a steep cutoff – but you'd only need it for one channel, so the computational load might be manageable. By the way, if it works for one channel, and you can assume spectral equidistance, willfully aliasing multiple channels atop of each other might reduce estimation ramdomness – again, this depends on the system you're trying to determine.

Notice that this is no universal approach – you'll need different estimators for different pulse shaping filters.

Timing recovery

You wanted to use the Polyphase Clock Sync timing estimator, which is an excellent choice – it uses a bank of slightly shifted filters to determine the error. You can simply apply that to your frequency adjusted multi-carrier input signal. Just make sure the samples per symbol are appropriate for the sampling rate you'd expect, and choose filter taps of a narrow low pass filter reflecting your estimated channel bandwidth! This might mean you have to interpolate your estimated RRC taps to the full sampling rate, but since this is a decimating operation internally, the computational load might be tolerable, even with the interpolated FIR. Other than that, decimating early in the signal chain is of course the way to minimize computational load.

$\endgroup$
  • $\begingroup$ Thanks for the detailed answer. This gives me a lot of directions to research, which was really the problem: tons of algorithms out there described in great detail, but not so much telling you which ones to read :) $\endgroup$ – Phil Frost Aug 17 '16 at 14:09
  • $\begingroup$ Good point, really! But I think you're off to a very good start with your PFB Clock Sync. simply "eyeball" an RRC parametrization, and stick that into your Clock Sync fed with the whole input signal for a start! $\endgroup$ – Marcus Müller Aug 17 '16 at 14:10
  • $\begingroup$ So something I hadn't realized until now: the polyphase clock sync is already a low-pass filter. And since each subcarrier is already effectively oversampled since it's just a small slice of the whole signal, I can get by with a small number of filters in the clock sync. So I'm betting after rough frequency matching, I can correct for clock differences with the central subcarrier, then pop out all the other channels with the channelizer and an RRC filter and demodulate them. Now just to determine how to prototype that in GNU Radio... $\endgroup$ – Phil Frost Aug 17 '16 at 18:11

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.