Transmitting data with QPSK using an SDR

Question

My question assumes that I want to transmit some data using QPSK using and SDR.

The SDR will be fed with IQ data and this will transmitted at a sample rate Fs and be up converted to a carrier frequency Fc.

The data needed to be transmitted will gets mapped onto QPSK symbols which are transmitted at a symbol rate lower than the sampling frequency.

Using the following in a trivial example:

• The bitstream to be transmitted is 00101101
• These 8 bits map onto four symbols as we are using QPSK
• Fs 10MHz
• The Symbol rate is 1M Symbols per second
• I know I need to do matched filtering before I transmit with an rrc filter.

Because I need to satisfy the sample rate and symbol rate I need transmit 10 samples for each symbol I want to transmit.

So my question is this, how do I present to the symbols to the filter? Do I feed in 4 symbols worth of samples (40 samples), with the first sample in each 10 set to the mapped value and the rest set to 0? Do I feed in the 4 symbols and let the filter interpolate?

(I also know that depending on the number of taps in the filter I would potentially need more samples before or after the data I want to transmit)

Answer 1

I know I need to do matched filtering before I transmit with an rrc filter.

No and not really.

No, because matched filtering happens in the receiver. If you've designed your transmit waveform correctly, then a matched filter gives you the strongest signal to noise ratio at the bit-slicer.

Not really, because a raised-root cosine filter is just one of the transmit waveforms you can choose. It's popular right now, to the point that people assume it's mandatory. It's very good, which is why it's popular. But it's not the only possible choice.

So my question is this, how do I present to the symbols to the filter? Do I feed in 4 symbols worth of samples (40 samples), with the first sample in each 10 set to the mapped value and the rest set to 0? Do I feed in the 4 symbols and let the filter interpolate?

That is a tactical, not a fundamental theoretical decision. You can:

1. Zero pad, and run the symbols through a "real" root raised cosine filter. This is, conceptually, the easiest.
2. Duplicate bits, and run the symbols through a filter whose output approximates a root raised cosine filter. This is both more obscure and more work, so unless you really need that intermediate result it's probably not worth it.
3. Take a polyphase approach, where you present your parent string of complex samples to an up-sampler which acts like you are discretely upsampling with zero-stuffing and then running it through a root-raised cosine filter. This will take fewer arithmetic operations, and especially will take fewer multiplies (which are more expensive). But in return for that it will involve:
   • more code
   • more obscure code
   • lots of counting on your fingers to get the indexes right (unless there's a function call in your SDR library that implements it already).

Something you didn't ask, but which is relevant, is that you probably want to split your binary stream into a stream of inphase symbols and quadrature symbols, four each, do the upsampling math on each one individually, and then combine those two final results into a single I/Q signal for conversion. This will take less math overall than turning the streams into complex numbers early on.

Answer 2

how do I present to the symbols to the filter? Do I feed in 4 symbols worth of samples (40 samples), with the first sample in each 10 set to the mapped value and the rest set to 0?

Yes -- but (as you mention) you'll want to pad zeros at the end, to let the filter output the full final pulse.

Make sure to line-encode the bits first: you don't want to feed the filters with ones and zeros, but with $a$ and $-a$, where $a$ is chosen appropriately for your SDR (for example, USRP devices work best with $a \approx 0.7$).

As Tim mentioned, you also need to decide how to feed the samples to the filters. There are two options:

• Deinterleave your symbols into two streams, I and Q, and use two filters.
• Convert your symbols to complex, and use one filter.

Finally, you may need to adapt your data to the interface your SDR offers. For example, USRPs (and in fact all other SDRs I have experience with) want complex floating-point samples.