Non-real-time WiFi (Pluto + MATLAB)

Whatever your existing experimental hardware+software setup is at FR1, the Pi-Radio system can extend its operation into the FR3 bands. In this example, we take an ADALM-PLUTO SDR, and extend its operation into the FR3 bands using the Pi-Radio 2-ch FR3 front-end. This example features code that runs in MATLAB, and is adapted from the one available at Mathworks website here. You should know that MATLAB has tons of excellent examples of wireless experiments that run on SDRs like the USRP or Pluto. We highlight just one such example, and encourage you to do the others on your own.

In this example, the same Pluto device is used both as a transmitter and receiver. We use the same Pi-Radio box on the transmit and receive side (you can extend the example to use independent TX and RX hardware). It is important to note that this is a "non-real-time" example: the received IQs are not processed in real time. In fact, the receiver grabs a certain number of samples, processes them "offline", and then grabs the next set of samples. While the processing is taking place, the IQ samples currently being received are discarded. However, the example demonstrates the power of MATLAB and its reference examples to get real-world experiments built fast.

Step 1: Get the experiment working at FR1 with cabled loopback

Simply loop the TX signal from the Pluto back into the RX port, making sure you have 40dB of attenuation in this signal path. Failure to add the attenuation can damage your Pluto. The hardware setup looks like this:

Download the code here: https://github.com/pi-radio/tutorials-demos

The relevant file is "pluto_wifi_matlab.m". Run the code. Here's what the code does:

• Takes an image file (i.e., a picture / photograph)

• Modulates this data into WiFi packets

• Transmits these packets continuously over the air, with a small gap between the packets

• Thee RX side simply grabs the received IQ samples "iter" times (See like 172). For each such set of captured samples, the code processes the grabbed samples, and attempts to decode the packets to reconstruct the image. The received image is displayed.

• For each packet, the received spectrum and constellation are continuously updated

It is important to note that to send one image file, around 60 packets are needed. The time taken by the MATLAB code to do the signal processing on the received samples is several seconds for a single image. In the time that MATLAB is processing the received (i.e., grabbed) samples, the currently streaming samples are discarded. This is why this example is "non-real-time". Once you are satisfied that you understand the FR1 experiment, move on to extending the experiment to FR3.

Step 2: Extend the Expereiment to FR3

To extend the experiment to FR3, modify the hardware setup to look like this:

Make sure that the attenuators/cables that you use are rated appropriately. For example, the cables that carry FR3 signals must be FR3 rated. It is also a very good idea to place a low-pass filter (perhaps with a 1.4 GHz cutoff) in series with the FR1 20dB attenuators on both the TX and RX side. This will help clean up the signals between the Pluto and the Pi-Radio system.

Assume that the Pi-Radio 2-ch FR3 system has an IP address of 192.168.137.51, with netmask 255.255.255.0. Make sure your host computer has a different IP address on the same subnet. In your web browser address bar, enter "192.168.137.51:5006" and press Enter. In about 20 seconds, a GUI should appear. Configure the GUI as shown below.

Configure the GUI as follows:

• Set the FR1 center frequency to 0.7 GHz. Note that this is offet by about 300 MHz from the Pluto center frequency of 1 GHz for reasons explained here

• Set the FR3 center frequency to 10 GHz

• Set the TX1 and RX1 gains to 30. Here, we have assumed that on both the TX and RX side, you have used channel 1 on the Pi-Radio 2-ch FR2 front-end

• Optionally, set the LO suppression appropriately as described here

Re-run the MATLAB code. You should observe the following:

Observe the MATLAB workspace / command window. Look at the logs scrolling by. You will see that eeach image takes 65 packets to transmit over the air. Observe the bit error rate that is also displayed.

Next Steps:

1. Play around with different gain settings on the Pluto as seen on lines 12 and 13 of the code. Also play around with the gains on the Pi-Radio front-end using the GUI. Observe that lowering the gain leads to dirtier constellations, while increasing the gain by too much leads to saturation and signal degradation. This illustrates the fact that while extending an FR1 experiment to FR3, it is absolutley essential to get the gain settings right.

2. Play around with the modulation and coding scheme (MCS) chosen on line 93 of the code. 

3. Plot the EVMs (see line 195 and 196 of the code)

4. Change the scaling factor on line 48. Observe how the number of packets needed for a single image change.

5. Go through the MATLAB code and dig in to learn how the following are done: frame boundary detection, frequency offset correction, timing offset correction, channel estimation, equalization, and so on. You can spend several hours digging in to learn how reeal-world systems perform DSP.

6. Find other examples on the Mathworks website that run on various SDRs (Pluto, USRP, RFSoC, etc). Get these examples working, and then extend their operation into the FR3 bands with the Pi-Radio 2-ch FR3 SDR front-end. MATLAB has tons of really fantastic examples that you can run on SDRs.