Name: wenet
Owner: Project Horus
Description: Wenet ("The Swift One") - Modulator and glue code for the Project Horus 115kbps imagery payload.
Created: 2016-03-05 07:18:54.0
Updated: 2018-05-15 19:10:28.0
Pushed: 2018-05-03 10:16:42.0
Size: 5755
Language: Python
GitHub Committers
User | Most Recent Commit | # Commits |
---|
Other Committers
User | Most Recent Commit | # Commits |
---|
Modulator and glue code for the 115kbps SSDV experiment.
The transmit side is designed to run on a Raspberry Pi, and the UART (/dev/ttyAMA0) is used to modulate a RFM98W (yes, a LoRa module) in direct-asynchronous mode. I expect other transmitters could probably be used (i.e. NTX2's or similar) at lower bandwidths.
The above image was captured on Horus 42, and downlinked via Wenet. The original downlinked resolution was 1920x1440, and has since been re-sized. The full resolution version is available here: http://rfhead.net/temp/horus_42_full.jpg
Refer to the wiki pages for installation/usage instructions.
ssdv
binary needs to be available on the PATH.pip install crcmod
)apt-get install python-numpy
pip install pyqtgraph
)rx/rx_ssdv.py
- Reads in received packets (256 byte SSDV frames) via stdin, and decodes them to JPEGs. Also informs other processes (via UDP broadcast) of new ssdv and telemetry data.rx/rx_gui.py
- Displays last received image, as commanded by rx_ssdv.py via UDP.tx/init_rfm22b.py
- Set RFM22B (attached via SPI to the RPi) into Direct-Asynchronous mode.tx/init_rfm98w.py
- Set RFM98W (attached via SPI to the RPi) into Direct-Asynchronous mode. Note that this requires pySX127x from https://github.com/darksidelemm/pySX127xtx_picam_gps.py
- Captures pictures using the PiCam, overlays GPS data and transmits them.python compress_test_images.py
from within ./test_images/ to produce the set of test ssdv-compressed files.tx_test_images.py
transmits a stream of test images out of the RPi UART. Check the top of the file for settings.rx_tester.py
produces a stream of packets on stdout, as would be received from the fsk_demod modem.python rx_tester.py | python rx_ssdv.py
to feed these test packets into the command-line ssdv rx script.--partialupdate N
to the above command to have rx_gui.py update every N received packets.gcc -fPIC -shared -o ldpc_enc.so ldpc_enc.c
to do this.python WenetPiCam.py (might need sudo to access camera & SPI) or
python tx_test_images.py` on the transmitter Raspberry Pi. There's also a start_tx.sh bash script which also sets up a RFM22B or RFM98W. I run this bash script from /etc/rc.local so it starts on boot.To be able to run a full receive chain, from SDR through to images, you'll need:
GnuRadio + libraries for whatever SDR you plan on using.
fsk_demod
, drs232_ldpc
, 'tsrc' from codec2-dev. You can get these using
svn checkout http://svn.code.sf.net/p/freetel/code/codec2-dev/
Note that codec2 needs speex and libsamplerate libraries. You can get these using: apt-get install speed-* libsamplerate0-dev
cd codec2-dev && mkdir build-linux && cd build-linux && cmake ../
Go back to the main codec2-dev directory and:
Build drs232_ldpc
(the packet de-framer & FEC) using gcc src/drs232_ldpc.c src/mpdecode_core.c -o src/drs232_ldpc -Wall -lm
Build 'tsrc' (the fractional resampler) using gcc unittest/tsrc.c -o unittest/tsrc -lm -lsamplerate
Then copy build-linux/src/fsk_demod
, src/drs232_ldpc
, unittest/tsrc
and octave/fskdemodgui.py
to this (wenet) directory.
A few example gnuradio-companion flow-graphs are in the grc
directory, for different SDRs. These receive samples from the SDR, demodulate a 500KHz section of spectrum as USB, resamples them to fsbaud*8 (which fsk_demod requires), then presents these samples via a TCP sink, which is acting as a TCP server. You will probably need to modify these to set the appropriate receive frequency.
To receive the FSK data and display the images 'live', run:
In another terminal: python rx_gui.py
, which will listen via UDP for new images to display.
Start the appropriate GNURadio Companion Flowgraph. This will start listening on TCP port 9898. The GUI will not open until…
Start the FSK modem with:
nc localhost 9898 | ./fsk_demod 2XS 8 923096 115387 - - S 2> >(python fskdemodgui.py) | ./drs232_ldpc - - -vv| python rx_ssdv.py --partialupdate 16
It's possible to use csdr (Get it from https://github.com/simonyiszk/csdr ) to perform the sideband demodulation.
Example (RTLSDR):
rtl_sdr -s 923096 -f 440980000 -g 35 - | csdr convert_u8_f | csdr bandpass_fir_fft_cc 0.05 0.45 0.05 | csdr realpart_cf | csdr gain_ff 0.5 | csdr convert_f_s16 | ./fsk_demod 2XS 8 923096 115387 - - S 2> >(python fskdemodgui.py) | ./drs232_ldpc - - -vv| python rx_ssdv.py --partialupdate 16
This mess of a command line (bash piping, yay!) receives samples from the rtlsdr, filters out the upper 'sideband' of the received bandwidth, then throws away the imaginary part and convert to 16-bit shorts. The signal is then fed into fsk_demod (the FSK modem). Debug output (on stderr) from the modem is piped into a python GUI), while the received soft-decision 'bits' are piped into drs232_ldpc, which does de-framing and LDPC error correction. Packets which pass checksum are then passed onto the rx_ssdv.py python utility for assembly into images.
On my flights the centre frequency of the transmitter is around 441.2 MHz, so I tune the RTLSDR to just below 441 MHz to sit the signal roughly in the middle of the passband.
It should be quite possible to use other SDRs (i.e. the AirSpy) with appropriate tweaking of the filter and source sample type conversion parameters.