# BPSK Revisited: Modulation and Demodulation

In my most recent post, I was able to encode and send binary ascii messages via MATLAB. My output was just a 1x280-bit vector with data points along it, resulting in either the BPSK wave or the B-FSK (binary frequency-shift keying) wave. However, this week I tackled demodulation and found many errors in my previous code. Enjoy! Intro to Beancounting

## BPSK Overview

Once again I will be taking from Wayne Tomasi’s Electronic Communication Systems: Fundamentals Through Advanced. I kept right at page 500-501 in the 1988 edition; the sections on BPSK modulation and demodulation. The book is a fantastic in-depth overview to modulation schemes, and I hope to use it for other applications. If you get bored of digital processing, there are sections on antenna propagation and even TDoA.

All BPSK does is modulate (change) the phase of a signal. In the binary case, it is either π or 0. This means the signal can only be sin(ωt) or -sin(ωt) with a sine reference.

BPSK can be elevated to QPSK; quadrature phase-shift keying. This is a little hard to explain. Basically, signals can have positive or negative, real or imaginary components independent of time. In BPSK, the signal only goes from (1,0) to (-1,0) and back and forth. In QPSK, the signal can be (1, i1), (-1, i1), (-1, -i1), (1, -i1). Now it has four possibilities. Below is an illustration of it, where Q (quadrature) is the imaginary portion, and I is the real (in-phase) portion: QPSK. Four Possibilities.

You’ll have to wait at least a week for me to try to modulate this way.

## Improvements on Code

If you remember last week, this was my finished product for BPSK and B-FSK: Last Week’s “finished” product

So it looks good enough lined up with the binary bit stream. However, my phase shifts are extremely off. The signal should be a smooth flow, and here I have a lot of “clock pulses;” areas where the phase shifts so rapidly there is an incredibly steep slope. I had to readjust my frequency within my signal (double it if I recall correctly), and I got a much more beautiful signal: This all looks much better. At each clock pulse, the sine wave intersects the time axis.

### MATLAB Binary encoding

As an aside, I noticed matlab did some odd things with binary encoding. I would get the same signal I transmitted, but it would be incomprehensible garbage. I learned my code for transforming text string to ascii binary vectors was deeply flawed:

``````%old version of binary encoding
string = 'test';
unicodeValues = double(string);
b = de2bi(unicodeValues);

b = reshape(b,1, []);
``````

This code results in a binary bit stream completely backwards from my input; if I put 0000001, I would receive 1000000. This code fixes it:

``````%improved binary code
string1 = 'test';
b = flip(de2bi(double(string1)),2);

b = reshape(b.',1, []);
``````

Just a weird matlab tick I saw. It must be something with MSB/LSB encoding.

## Demodulation

Now I have my output sine wave, and I want to decode it. The first step was to find the period of the signal and create a carrier (clock) wave. I had to interpolate from the wave I received because I wouldn’t truly know the frequency or duration in an actual receiver. The findpeaks function helped with this, although I used it on the absolute values of my signal. It looked like this:

``````z2 = abs(zz) %take the absolute value of received wave
[pks, locs] = findpeaks(z2);

T = length(pks);
%the length of total peaks are the period.

ts = 0:(1/T):10 %generate a vector the total length of the transmission.
``````

From here I used a detection scheme called a product detector.

``````test_signal = sin(pi*T/10*ts) %clock/carrier frequency

product_detector = test_signal.*zn %product detector

``````

The output of the product detector is actually kind of beautiful. It turns my BPSK into almost pulse-position modulation: On Top: BPSK with carrier wave. Bottom: Product dete_c_tor with clock signal

So all I had to do from here was threshold the wave bit-by-bit.

``````bitstream = zeros(1,length(product_detector));
%empty vector
for i=1:length(product_detector)

if product_detector(i) > 0
bitstream(i) = 1
end

if product_detector(i) <= 0
bitstream(i) = 0
end

end

binary_data = bitstream(5:10:end) %downsample to the middle bit
``````

I chose to use (i <= 0) = 0 because of my carrier wave. Using a cosine or -sine may yield different results.

## Decoding

The binary-stream to actual text was a lot of beancounting. I fed the single vector through a couple loops, and used the modulus function to determine whether or not I had a new ascii character. I assumed only lowercase ascii characters would be transmitted; resulting in 7 bits per character.

``````for i=1:length(binary_data)
temp_vector = [temp_vector, binary_data(i)]
if (mod(i,7) == 0)
%if bit is start of new character
final_binary = [final_binary; temp_vector]
%new column
temp_vector = [];
%clear register
end
end
``````

Finally, used some conversion magic and my data popped out! Success

## Improvements: Bit length, AWGN, and encryption

To test my robustness as an actual system, I added some gaussian white noise and a filter to my system. It was sort of like throwing a ball into the air and catching it back down; the minimal flight time was just enough to show my system worked. It worked great at an SNR of 20: Reception of BPSK with AWGN @ 20

My next step here is to add a better detection of period. Sometimes my bits will be off by 1, resulting in a whole cache of errors. With a 10-second, 4 letter pulse I do not usually have problems.

Encryption can also be a fun side project. The bitstream is already in binary, so RSA / AES / OTPs are pretty easy to implement. Just need a secure way to send the keys…

## Conclusion

I learned a lot from beancounting, arrays, vectors, and signal detection in this exercise. It’s the equivalent of a home-improvement weekend project for signals people; pretty fun to set up and play with all within a week. I will probably try more mod/demod products like this, such as FM, next week. Stay tuned!