File transfer using Packet and BPSK

This is a Proof of Concept design. Please leave comments in the Discussion tab above, or on the GNU Radio General Chat channel. See Chat.

This package consists of a packet transmitter, a channel simulation, and a packet receiver. It has been developed and tested with GNU Radio version 3.10.6.0. For Over The Air testing, a Transmit / Receive SDR module is used in place of the channel simulation.

Prerequisites
It is imperative that all of the prerequisites are studied before starting this one.


 * Example Usage of GNU Radio: PSK Modulation / Demodulation
 * Simulation_example: BPSK Demodulation
 * Packet Communications

Version v2.X.0.0
Version v2.1.1.0 has improvements to the  flowgraph.

Version v2.1.0.0 transmits the input file name. The  program displays the received file name.

Version v2.0.0.0 encodes all input files into Base64 for transmission. The file is decoded from Base64 to the original content in the  program.

Version v1.0.0.0
Version v1.0.0.0 uses an HDLC frame to prevent long strings of zero bytes. In spite of that, some binary files failed.

Download the gr-control software
1. Open a terminal window. 2. Change to the home directory. cd ~/ 3. If you don't have 'git', enter sudo apt install git 4. Clone the repository: git clone https://github.com/duggabe/gr-control.git 5. If you want a version other than the latest, do the following: cd ~/gr-control git checkout v2.x.x.x   # enter the desired version

Operation
''' * * NOTE: The order of starting the tasks is important! * *'''

Sending Non-text Files
Any text, binary, and other non-text files (such as PDF or PNG) can be sent. The file "~/gr-control/gr-logo.png" has been provided for testing. It is the GNU Radio logo.

Receiving the File
receives the BPSK signal and presents it to the Correlate Access Code - Tag Stream. That block detects the Access Code and passes the payload to the Stream_CRC32 to check for a valid CRC. If the CRC is good, the data is sent to the File_Sink.

1. Open a new terminal window. 2. Go to the gr-control/Receivers folder. cd ~/gr-control/Receivers 3. Execute the packet receiver. python3 -u pkt_rcv.py 4. A new window will open (titled "pkt_rcv") showing a QT_GUI_Constellation_Sink display and two QT_GUI_Time_Sinks.

Simulating Channel Impairments
There are two flowgraphs included to allow loopback testing of a transmitter and a receiver without using SDR hardware. Either operates **in place of** the `xmt_rcv_switch` program. The `chan_loopback` is for the digital modes such as BPSK packet. It allows introduction of noise, frequency offset, and timing offset.



1. Open another terminal window. 2. Go to the gr-control folder. cd ~/gr-control 3. Execute the loopback program. python3 -u chan_loopback.py 4. A new window will open (titled "chan_loopback") showing a chooser for the Sample rate. For the version 3.9 and 3.10 programs, select 768kHz. There are three sliders to introduce impairments, but for initial testing, leave them all as loaded.

Transmitting the File


The 'EPB: File Source to Tagged Stream' block is an Embedded Python Block which takes the place of a File_Source block, a Stream_to_Tagged_Stream block, and parts of a Burst_Shaper block. The Python block performs the following functions:
 * Send a preamble to allow the receiver to synchronize.
 * Read the file in "Pkt_Len" chunks.
 * Convert the data to Base64, which produces 4 bytes of output for every 3 bytes of input.
 * Send each Base64 chunk with revised "packet_len" tags.
 * Send a post-file filler to assure that any buffers have been flushed.

The content of the Embedded Python Block is shown here: pkt_xmt_epy_block_0.py

The preamble is composed of the '%' character, followed by 50 capital 'U's, followed by a ']'. It is repeated 100 times to allow the receiver to synchronize. The post-file filler is sent 40 times.

1. Open another terminal window. 2. Go to the gr-control/Transmitters folder. cd ~/gr-control/Transmitters 3. Execute the packet transmitter with the desired filename, for example: python3 pkt_xmt.py --InFile="../gr-logo.png" 4. A new window will open (titled "pkt_xmt") showing a QT_GUI_Time_Sink. 5. The file transmission will begin. The average throughput is 2,000 bytes per second. 6. The Time Sink display in the transmitter will show data bits with a 'packet_len' tag. 7. The Time Sink displays in the receiver will show data bits with a 'packet_len' tag. 8. When the file is complete, the transmit terminal will show "End of file".

Shutdown
1. Close the "pkt_xmt" window by clicking the 'X' in the upper right corner. 2. Close the "chan_loopback" window by clicking the 'X' in the upper right corner. 3. Close the "pkt_rcv" window by clicking the 'X' in the upper right corner.

Stripping the Preamble and Filler
The received file will be stored in "~/gr-control/Receivers/output.tmp". That file will contain up to 100 preamble packets, followed by the transmitted file with Base64 encoding, followed by filler packets.

A Python program has been written to strip those preamble and filler packets and decode the Base64 text:

1. Use the terminal window with the gr-control/Receivers folder. cd ~/gr-control/Receivers 3. Execute the  program. The last parameter (file name) can be whatever you wish as the output. Use the appropriate file extension! python3 strip_preamble.py output.tmp output.png

Over The Air Testing
Limited testing has been done using two computers with B200 mini and Pluto SDRs. Observations from these tests are:
 * Frequency differences between the two SDRs leads to the need to adjust the receiver tuning to get a good signal.
 * Using an ISM band can introduce a lot of noise.
 * Without Forward Error Correction, some packets get dropped.