This project is a modification of the OFDM tunnel code from gnuradio to use UHD.

Getting OFDM working seems to be an exercise in choosing the correct gains. The default
gain settings in the files work well for my N210s with WBX daughterboards, but they don't
work with my E100. Play around with gain settings if OFDM doesn't work well.

Another problem you may run into is subcarrier bandwidth. If you have a lot of subcarriers
distributed over not much bandwidth, it'll be much harder to receive anthing. I'm using a 
sample rate of 800kS/s with my N210s and an fft-length of 256. This seems to work pretty well
for me. If you use a larger sample rate, you can probably get away with a longer fft-length.

You may have to account for frequency offsets when using OFDM between two USRPs. You can do this 
manually by transmitting from one USRP on the desired frequency (in our examples 648.8M). At the
receiver, use an FFT to view the OFDM signal. There should be two null subcarriers right in the
center of the OFDM boxcar. Those should be centered around your center frequency. Adjust the 
tx frequency until it's as close as you can get. I didn't have to worry about this, but other
people on the GNURadio mailing list did (with their own OFDM applications).



To use the benchmark scripts:
-----------------------------
With the N210s
TX side: python benchmark_ofdm_tx.py -f 648.8M -v --gain=11.5 -M 15 --tx-amplitude=.8 --rate=1M
RX side: python benchmark_ofdm_rx.py -f 648.8M -v --rx-gain=17 --rate=1M

The files (as well as most of the other files in this project) make use of the
receive_path.py and transmit_path.py files to manage the OFDM encoding and decoding.

Tunnel.py
________
This file is intended to form a wireless tunnel between two computers using the TUN/TAP linux 
interface. I updated this file to use UHD (rather than the original USRP code), but I haven't tested it.


______________________

The following files are mainly for an 802.11af research project done at the University of Washington Fundamentals of Networking Lab.
http://www.ee.washington.edu/research/funlab/


To use csma_ca_sm_test:
_______________________
Note that this isn't actually 802.11, it's just a custom CSMA/CA MAC that approximates (poorly)
what is used by 802.11 so that the qp algorithm as implemented on the USRPs can be compared to
something with the same hardware limitations.

This file is the PHY and test implementation of the csma/ca MAC. The MAC (contained in 
csma_ca_mac_sm.py) handles all of the state machine transitions and timing. The test file
instantiates the MAC and generates packets. The test file is set up to run for a certain
amount of time and then stop and print data on packets sent and received. 

To run a test, you have to run the following command on two different csma/ca nodes. The nodes
must have the same frequency (-f option), but different addresses (--address option). Actually,
assuming you're using the same type of USRP, all these options should probably be the same between 
nodes (except the address).

python csma_ca_sm_test.py -f 640M --fft-length=256 --occupied-tones=128 --rx-gain=14 --pkt-gen-time=.05 --address=a --packets=3000 --backoff=.005 --ctl=.04 -r 800000 --cw-min=2 --pkt-padding=1000 --tx-gain=11.75

To use qpcsmaca_test:
_____________________
This file is similar to the csma_ca_sm_test file, but it also implements cognitive radio behavior
by switching frequencies if the present frequency is occupied. 

The idea is that during the backoff (after DIFS) the nodes will sense the present frequency for a
licensed primary user. This is known as a quiet period sense, since theoretically all qpCSMA/CA nodes
will not be transmitting at this point. If a primary user is sensed as being present, then the node will
begin sensing all available channels for one that is unoccupied. It will then switch to that unoccupied
channel and 

Relevant files are:
qpcsmaca_test.py - implement the PHY, instantiate MAC and sense, generate packets and manage test
qpcsmaca_mac.py - implement the MAC state machine and manage sensing
sense_path.py - implement sense algorithms (this is also where the available channels are hard-coded)

python qpcsmaca_test.py --fft-length=256 --occupied-tones=128 --address=a --autoselect-freq --chan-bandwidth=800000 --thresh_primary=-53 --qp-interval=10 --test-time=300

Running the qpcsmaca code isn't very worthwhile if you aren't also modeling a primary user of the spectrum.

To use simulated_primary:
_________________________
This file transmits OFDM packets on a set of channels (available channels are hardcoded in, just as they
are in sense-path for the qp algorithm). The channels can be chosen randomly or serially. The parameters
for the primary aren't actually too important for the tests this file is intended for. Since we're not
trying to transmit data (just occupy a frequency band) I chose these parameters empirically to best
occupy a certain frequency band without disturbing adjacent frequencies. 

These parameters work alright for the E100, but it may be worth rewriting the simulated primary from scratch to better match the real world TV signals. It's kind of a pain to tune the qp algorithm and the
simulated primary to actually work well together.

python simulated_primary -f 650M --fft-length=1024 --occupied-tones=900 --gain=17 --tx-amplitude=.95 -M 40 --rate=1000000 --random