Pseudorandom Multiband Frequency Hopping for Interference Avoidance Using GNU Radio and USRP Thomas Bell

Kevin Gajewski

Anthony Hsu

Advisors: Yu-Dong Yao, Fangming He July 24, 2009

Abstract Now that computer processor speeds are much faster, the once only theoretical concept of Software-Defined Radio is now a practical reality. Using an open source software-defined radio package called GNU Radio and a basic radio hardware component called the Universal Software Radio Peripheral (USRP), we have implemented a primitive cognitive radio system that uses energy detection to sense interference and pseudo-random frequency hopping to then avoid it. We wrote our Pseudorandom Multiband Frequency Hopping Program in Python and tested it using the USRP with a Flex 900 daughterboard installed. Using a spectrum analyzer to monitor the transmission signal and a signal generator to create interference (simulated by a strong signal), we tested our program and it was successful in detecting and avoiding interference. Our program is a demonstration of the capabilities of software-defined radio and the cognitive radio systems that can be then be implemented using this technology.

Introduction Software-Defined Radio (SDR) is a radio communication system that implements most of its components in software instead of hardware. It has been theorized that SDR can become more intelligent and be able to communicate with other radios and

efficiently use sections of the spectrum that are unused; this evolution of a smarter SDR would be Cognitive Radio. For SDR to be enabled as a Cognitive Radio it must be able to achieve spectrum sensing, interference detection, interference avoidance, and efficiently transmit in the spectrum without causing interference. In this paper we will go into detail about the software kit, hardware, instruments, and programming that were used to create our SDR, test it, and allow it to show characteristics of a Cognitive Radio by exhibiting PseudoRandom Multi-Band Frequency Hopping.

GNU Radio To implement the software components that a Software-Defined Radio uses, a software kit called GNU Radio was installed. GNU is a project that was created to provide a Unixlike operating system environment that is comprised of free software. GNU is a recursive acronym that stands for GNU is not Unix. Building upon the GNU free software concept, GNU Radio is a free software implementation of actual radio hardware. It is enabled by signal processing blocks that can be used to implement software defined radio on external RF hardware. Until recently, it was necessary to implement those signal processing blocks in actual hardware. However, since processing power has increased steadily, it has recently become feasible to implement those blocks in software.

In GNU radio, most of the applications can be written in the Python programming language. This is generally the method of choice, considering that it is supported by default. However, the actual signal processing paths are written in the C++ programming language, and uses processor optimization whenever possible. Therefore, it is possible to write GNU Radio applications in many languages that offer C++ bindings. GNU Radio also supports the development of signal processing algorithms using recorded or generated data. This makes it possible to use GNU Radio without RF hardware. Even though GNU Radio applications can be implemented using various high-level languages, things can be further simplified by using the GNU Radio Companion (GRC). GRC is a graphical frontend to GNU Radio that allows the user to create signal flow-graphs, which generate Python source code. Although we did not use the GRC for our actual experiment, we did use a few signal processing blocks when testing out its capabilities; these blocks were:  signal source  USRP source  type conversions  FFT sink  audio sink  USRP sink  variables and variable sliders

Universal Software Peripheral (USRP)

USB 2.0 interface, or a Gigabit Ethernet port. These devices include the USRP and the USRP2, respectively. Certain daughterboards, which are installed in the USRP, allow for these devices to be used with various frequency bands. As with GNU Radio, the USRP and USRP2 designs are open source. Therefore, all USRP and daughterboard schematics are freely available for download. In this research, two USRP devices were used with the project. Both of these devices used the Flex 900 daughterboards, which allowed for the transmission and reception of signals between 800 MHz and 1000 MHz. These devices were connected via USB 2.0 to two computers, which were operated by the Ubuntu Linux 9.04 operating system.

Lab Instruments Two instruments were used to assist in testing of the Pseudorandom Multiband Frequency Hopping program. Both of the instruments were made by Agilent Technologies. The first of these instruments, the Agilent E4445A PSA Series Spectrum Analyzer was used to monitor and review the frequency spectrum and watch the actions of the transmitter. The key specifications are below:

Radio

To be able to actually conduct our experiment, an external RF hardware that works in conjunction with GNU Radio needed to be used. The Universal Serial Radio Peripheral (USRP), created by Ettus Research LLC, is the hardware that seemed best to use, it also is recommended by GNU Radio. The USRP allows for the creation of a software radio utilizing a computer with a

Figure 1: Agilent E4440A PSA Series Spectrum Analyzer

Performance of the Agilent E4445A PSA Series Spectrum Analyzer:    

+/- 0.19 dB absolute amplitude accuracy -155 dBm displayed average noise level (DANL) -118 dBc/Hz phase noise at 10 kHz offset 81 dB W-CDMA ACLR dynamic range

Signal Characteristics of the Agilent E4438C ESG Vector Signal Generator:    



Analysis bandwidth:  

 

Standard 10 MHz analysis bandwidth Optional 40 or 80 MHz analysis bandwidth to capture and measure complex signals. -78 dB third order intermodulation for 40 or 80 MHz analysis bandwidth Up to 300 MHz analysis bandwidth for calibrated VSA measurements

The second instrument used was the Agilent E4438C ESG Vector Signal Generator. This was used to transmit a signal that the transmitter and program would see as interference. The key specifications are below:

250 kHz to 1, 2, 3, 4, or 6 GHz (0.01 Hz resolution) +17 dBm output power 160 MHz RF modulation bandwidth Modulation and Sweep: o AM, FM, ѲM, and pulse o ASK, FSK, MSK, PSK, QAM, custom I/Q Step or list, frequency and power

Baseband Generation and Signal Creation: 

 



Internal baseband generator (80 MHz RF BW): arbitrary waveform and real-time I/Q 64 Msa playback memory and 1 Gsa storage Signal generation: WLAN, WiMAX, W-CDMA, cdma2000, GSM, DVB, multitone Digital I/O, fading, and PC waveform streaming

Automation and Communications Interface:   

10BaseT LAN and GPIB SCPI and IVI-COM drivers Backwards compatible with all ESG signal generators

Multiband Frequency Hopping

Figure 2: Agilent E4438C ESG Vector Signal Generator

Frequency hopping is a method of changing carrier frequencies periodically. Usually, only one band is used, with the carrier frequency just shifting among the channels within the band. However, one can also use multiple bands for frequency hopping. This is called multiband frequency hopping and is what we implemented in our experiment. There are many advantages to implementing a frequency hopping radio system. First, by

changing frequencies periodically, the radio system is less susceptible to interference, especially if interference detection is implemented in the system. Secondly, frequency hopping makes signals difficult to intercept, making frequency hopping a useful tool in military applications. Finally, frequency hopping allows the radio frequency spectrum to be utilized more efficiently. Currently, much of the radio frequency spectrum is not heavily used or is used only for a short period in every twentyfour hours. Also, depending on one's location, different frequency bands will be used more often or more heavily than others. With multiband frequency hopping, bands that are rarely used by their licensed users (primary users) could be utilized by other users (secondary users) when primary users are not using them. This could help reduce the frequency of dropped signals in busy networks such as mobile phone carrier bands. To synchronize the transmitter and receiver in a frequency hopping radio system, there are several frequency hopping algorithms that have been developed. One example is explained in a Texas Instruments paper entitled “Implementing a Bidirectional Frequency Hopping Application With TRF6903 and MSP430” by Shreharsha Rao. In our experiment, since our purpose was to demonstrate a frequency hopping radio system using GNU Radio and a USRP, we simply implemented pseudorandom frequency hopping. The frequency hopping is determined by a seed value specified by the user as a parameter to the program.

Implementation To implement pseudorandom multiband frequency hopping, a few things must be considered. First, a certain range of frequencies should be considered (for example: from 800 MHz to 1000 MHz).

Then the section of the spectrum that is being used should be split up into five bands of frequencies and those bands should be further segmented into five channels of frequencies (to continue the previous example: five 40-MHz bands and each one of the bands will be split up into five 8-MHz channels). A way for the radio to detect interference should be designated, such as using an energy threshold. When running this program, two parameters would have to be set during initialization: which of the five bands for the radio to start transmitting inside of, and a number which would be used as a seed to generate the random numbers that determine the sequence of pseudo-random frequencies. In theory, with just the starting band and seed, a receiver could be able to receive everything this program and it’s transmitter were transmitting because they would able to generate the same sequence of pseudorandom frequencies. The program would start transmitting in one of the five channels in the specified band, and read the energy readings of the other 4 channels. For every specified time interval (i.e. one second) the transmitted signal will jump to a different channel within the band, again while the other four channels’ energy readings are being monitored. When the average energy reading exceeds a predefined threshold, the program would see this as interference and move its transmission into a different band where it would continue to do the same thing.

System Model and Protocol Figure 3 depicts the setup of the host PC and the USRP and Figure 4 depicts the flow of our Pseudorandom Multiband Frequency Hopping Program.

Figure 3: Universal Software Radio Peripheral Setup

channels. The user is able to decide which band the program will start transmitting in and what the seed number is. The schemed energy detection in the previous section was implemented for detecting the interference and avoiding it. We used the Agilent E4438C ESG Vector Signal Generator to create interference in the band we were transmitting in, and watched the program hop to a different band. Though our experiment only focuses on the transmitter, in theory, if there were a receiver as well, you could synchronize it with the transmitter by sending the seed so that it could also generate the same sequence of pseudorandom frequencies.

Future work

Figure 4: Pseudorandom Multiband Frequency Hopping Program Flow Chart

Experimentation To test out our Pseudorandom Multiband Frequency Hopping program without interfering with any licensed bands we decided to use the 900MHz to 1000 MHz range. Within this part of the spectrum we broke it down into five 20 MHz bands, and within those five bands we made five 4 MHz

Although the group has been able to showcase some examples of a cognitive radio, our model is still quite primitive. Some future work in improving our Cognitive Radio includes implementing new and more advanced frequency hopping algorithms. For now we have just been transmitting a signal source but in the future we also like to be able to transmit data, audio, and video. Throughout this experiment we have not had a receiving radio involved but in the future it would be useful to have one involved to receiver whatever the transmitter is sending, this might be able to be done by giving both USRPs the same hopping algorithm and using the aforementioned same seed number. Another thing we may look into in the future is running programs through the GRC, since you can see everything on it’s interface and you can write your own GRC blocks, the GRC could prove to be very useful in making creating programs easier and faster. Lastly, a reasonable experiment to try would be to see how different transmitting cognitive radios communicate with each other, and if they can stay out of each other’s way.

Acknowledgments

References

We would like to thank Professor Yu-Dong Yao for organizing and coordinating the Stevens Research Experience for Undergraduates program, for giving us guidance and support over the course of the project, and for providing valuable feedback on our research and paper. We also want to thank Fangming He for serving as our graduate student mentor, explaining some signal processing concepts that were unfamiliar, helping us with technical problems, and providing advice and ideas along the way. Finally, we thank the National Science Foundation for providing the funding which made this research possible in the first place and Stevens Institute of Technology for hosting this program.

[1] Blossom, Eric; et al. GNU radio. http://www.gnu.org/software/gnuradio/. [2] Mitola, J., III (1999). Software radio architecture: a mathematical perspective. IEEE Journal on Selected Areas in Communications, 514-538. [3] Mitola, J., III; Maguire, G. Q., Jr. (1999). Cognitive radio: making software radios more personal. IEEE Personal Communications, 13-18. [4] Rao, S. (2004). Implementing a Bidirectional Frequency Hopping Application With TRF6903 and MSP430. Dallas, TX: Texas Instruments.

Appendix Source code of pseudorandom multiband frequency hopping program, pseudo_rand_freq_hopping.py (http://sites.google.com/site/ahsustevens/sourcecode/pseudo_rand_freq_hopping.py) #!/usr/bin/env python # # Copyright 2005,2007,2008,2009 Free Software Foundation, Inc. # # This file is part of GNU Radio # # GNU Radio is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 3, or (at your option) # any later version. # # GNU Radio is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with GNU Radio; see the file COPYING. If not, write to # the Free Software Foundation, Inc., 51 Franklin Street, # Boston, MA 02110-1301, USA. #

### IN ORDER FOR THIS PROGRAM TO WORK ### # This program requires a USRP with the Flex 900 RX and Flex 900 TX # daughterboards installed. This program works best with default settings. from gnuradio import gr, gru, eng_notation, optfir, window from gnuradio import audio from gnuradio import usrp from gnuradio.eng_option import eng_option from grc_gnuradio import usrp as grc_usrp from optparse import OptionParser from usrpm import usrp_dbid import sys import math, random import struct class tune(gr.feval_dd): """ This class allows C++ code (bin_statistics_f.cc) to callback into python to change USRP RF center Frequency. """ def __init__(self, tb): gr.feval_dd.__init__(self) self.tb = tb def eval(self, ignore): """ This method is called from gr.bin_statistics_f when it wants to change the center frequency. This method tunes the front end to the new center frequency, and returns the new frequency as its result. """ try: # We use this try block so that if something goes wrong from here # down, at least we'll have a prayer of knowing what went wrong. # Without this, you get a very mysterious: # # terminate called after throwing an instance of 'Swig::DirectorMethodException' # Aborted # # message on stderr. Not exactly helpful ;) new_freq = self.tb.set_next_freq() return new_freq except Exception, e: print "tune: Exception: ", e """ Class to parse the incomming messages sent by bin_statistics. 1) It extracts the center frequncy and the incomming data vector length 2) Convert received data string to a floating point format. 3) Store the output in the "data" array """ class parse_msg(object): def __init__(self, msg): self.center_freq = msg.arg1() self.vlen = int(msg.arg2()) assert(msg.length() == self.vlen * gr.sizeof_float) # FIXME consider using Numarray or NumPy vector t = msg.to_string() self.raw_data = t self.data = struct.unpack('%df' % (self.vlen,), t) class my_top_block(gr.top_block): def __init__(self): gr.top_block.__init__(self)

usage = "usage: %prog [options] min_freq seed" parser = OptionParser(option_class=eng_option, usage=usage) parser.add_option("-g", "--gain", type="eng_float", default=None, # Also see line 227 below. help="set gain in dB (default is midpoint)") parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0,0), help="select USRP Rx side A or B (default=A)") parser.add_option("", "--tune-delay", type="eng_float", default=1e-3, metavar="SECS", help="time to delay (in seconds) after changing frequency [default=%default]") parser.add_option("", "--dwell-delay", type="eng_float", default=10e-3, metavar="SECS", help="time to dwell (in seconds) at a given frequncy [default=%default]") parser.add_option("", "--real-time", action="store_true", default=False, help="Attempt to enable real-time scheduling") parser.add_option("-B", "--fusb-block-size", type="int", default=0, help="specify fast usb block size [default=%default]") parser.add_option("-N", "--fusb-nblocks", type="int", default=0, help="specify number of fast usb blocks [default=%default]") (options, args) = parser.parse_args() if len(args) != 2: parser.print_help() sys.exit(1) valid_min_freq = False allowed_min_freq = (900e6, 920e6, 940e6, 960e6, 980e6) for i in allowed_min_freq: try: if eng_notation.str_to_num(args[0]) == i: valid_min_freq = True except: pass if not valid_min_freq: print "Error: min_freq must be 900e6, 920e6, 940e6, 960e6, or 980e6." sys.exit(1) try: float(args[1]) except Exception, e: print "seed must be a real number." sys.exit(1) if not options.real_time: realtime = False else: # Attempt to enable realtime scheduling r = gr.enable_realtime_scheduling() if r == gr.RT_OK: realtime = True else: realtime = False print "Note: failed to enable realtime scheduling" # If the user hasn't set the fusb_* parameters on the command line, # pick some values that will reduce latency. if 1: if options.fusb_block_size == 0 if realtime: options.fusb_block_size options.fusb_nblocks else: options.fusb_block_size options.fusb_nblocks

and options.fusb_nblocks == 0: # be more aggressive = gr.prefs().get_long('fusb', 'rt_block_size', 1024) = gr.prefs().get_long('fusb', 'rt_nblocks', 16) = gr.prefs().get_long('fusb', 'block_size', 4096) = gr.prefs().get_long('fusb', 'nblocks', 16)

#print "fusb_block_size =", options.fusb_block_size #print "fusb_nblocks =", options.fusb_nblocks ### BLOCKS in the flow graph and their parameters ### self.u = usrp.source_c(fusb_block_size=options.fusb_block_size, fusb_nblocks=options.fusb_nblocks)

self.fft_size = 64 self.src_freq = src_freq = 400 # signal source frequency self.samp_rate = samp_rate = 32000 self.interpolation = interpolation = 16 self.amp = amp = 10 adc_rate = self.u.adc_rate() # 64 MS/s usrp_decim = 16 self.u.set_decim_rate(usrp_decim) self.freq_step = usrp_rate = adc_rate / usrp_decim

# 4 MHz by default

self.min_freq = eng_notation.str_to_num(args[0]) self.max_freq = self.min_freq + 20e6 self.seed = float(args[1]) random.seed(self.seed) print "seed = %s" % (self.seed) if self.min_freq == 900e6: self.band = elif self.min_freq == 920e6: self.band elif self.min_freq == 940e6: self.band elif self.min_freq == 960e6: self.band elif self.min_freq == 980e6: self.band

0 = = = =

1 2 3 4

self.min_center_freq = self.min_freq + self.freq_step/2 nsteps = 4 self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step) self.next_freq = self.min_center_freq x = random.randint(0,4) self.tx_freq = tx_freq = self.min_freq + self.freq_step/2 + x * self.freq_step self.curr_tx_ch = 0 # Configuration of the USRP Sink self.usink = grc_usrp.simple_sink_c(which=0, side="A") self.usink.set_interp_rate(interpolation) self.usink.set_frequency(tx_freq, verbose=True) self.usink.set_enable(True) self.usink.set_auto_tr(True) # Configuration of the signal source self.sig_src = gr.sig_source_c(samp_rate, gr.GR_SIN_WAVE, src_freq, amp, 0) self.u.set_mux(usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec)) self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec) print "Using RX d'board %s" % (self.subdev.side_and_name(),) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size) mywindow = window.blackmanharris(self.fft_size) fft = gr.fft_vcc(self.fft_size, True, mywindow) #This loop is calculating the gain of the applied window power = 0 for tap in mywindow: power += tap*tap c2mag = gr.complex_to_mag_squared(self.fft_size) # use c2mag = gr.complex_to_mag(self.fft_size) if you want the power # FIXME the log10 primitive is dog slow log = gr.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size)) tune_delay = max(0, int(round(options.tune_delay * usrp_rate / self.fft_size))) # in fft_frames dwell_delay = max(1, int(round(options.dwell_delay * usrp_rate / self.fft_size))) # in fft_frames self.msgq = gr.msg_queue(16) self._tune_callback = tune(self) # hang on to this to keep it from being GC'd stats = gr.bin_statistics_f(self.fft_size, self.msgq,

self._tune_callback, tune_delay, dwell_delay) # FIXME leave out the log10 until we speed it up #self.connect(self.u, s2v, fft, c2mag, log, stats) ### CONNECTIONS ### self.connect(self.u, s2v, fft, c2mag, stats) # USRP to FFT plot and various data sinks self.connect((self.sig_src, 0), (self.usink, 0)) # signal source to USRP sink if options.gain is None: # if no gain was specified, use the mid-point in dB g = self.subdev.gain_range() options.gain = float(g[0]+g[1])/2 # = 45 for Flex 900 RX board # (gain range from 0 to 90) self.set_gain(options.gain) print "gain =", options.gain def set_next_freq(self): target_freq = self.next_freq self.next_freq = self.next_freq + self.freq_step if self.next_freq > self.max_center_freq: self.next_freq = self.min_center_freq if target_freq == self.tx_freq: target_freq = self.next_freq self.next_freq = self.next_freq + self.freq_step if self.next_freq > self.max_center_freq: self.next_freq = self.min_center_freq if not self.set_freq(target_freq): print "Failed to set frequency to", target_freq return target_freq def set_freq(self, target_freq): #RX frequency """ Set the center frequency we're interested in. @param target_freq: frequency in Hz @rypte: bool Tuning is a two step process. First we ask the front-end to tune as close to the desired frequency as it can. Then we use the result of that operation and our target_frequency to determine the value for the digital down converter. """ return self.u.tune(0, self.subdev, target_freq) def set_gain(self, gain): self.subdev.set_gain(gain) def set_tx_freq(self, new_freq): self.tx_freq = new_freq self.usink.set_frequency(self.tx_freq) def set_new_random_tx_freq(self): x = random.randint(0,4) while x == self.curr_tx_ch: x = random.randint(0,4) self.set_tx_freq(self.min_center_freq + x*self.freq_step) self.curr_tx_ch = x # current TX channel, between 0 and 4 def hop_to_new_band(self): x = random.randint(0,4) while x == self.band: x = random.randint(0,4) self.min_center_freq = 900e6 + x*20e6 + self.freq_step/2 self.max_center_freq = self.min_center_freq + 16e6 self.next_freq = self.min_center_freq self.band = x # current TX channel, between 0 and 4 self.set_new_random_tx_freq() self.set_amp()

def set_amp(self): if self.band == 0: self.amp = 10; self.threshold = 8e9 # different thresholds used because of variations in signal strength # due to antenna and USRP elif self.band == 1: self.amp = 10; self.threshold = 8e9 elif self.band == 2: self.amp = 10; self.threshold = 8e9 elif self.band == 3: self.amp = 10; self.threshold = 8e9 elif self.band == 4: self.amp = 10; self.threshold = 8e9 self.sig_src.set_amplitude(self.amp) def main_loop(tb): i = 0 tb.set_amp() while 1: # Get the next message sent from the C++ code (bin_statistics) # It contains the center frequency and the mag squared of the fft m = parse_msg(tb.msgq.delete_head()) # This is a blocking call. # Print center freq so we know that something is happening... print "New center frequency: %0.1f" % (m.center_freq) # FIXME do something useful with the data... # # # #

m.data are the mag_squared of the fft output (they are in the standard order. I.e., bin 0 == DC.) m.raw_data is a string that contains the binary floats. You could write this as binary to a file.

i += 1 if i == 40: # this counter is used to slow down the rate the transmission frequency changes i = 0 tb.set_new_random_tx_freq() y = 0 for x in m.data: y += x avg_energy = y / tb.fft_size if avg_energy > tb.threshold: print "*******************************%0.1f is > %d" % (avg_energy, tb.threshold) tb.hop_to_new_band() if __name__ == '__main__': tb = my_top_block() try: tb.start() # start executing flow graph in another thread, and return the control to the python program main_loop(tb) except KeyboardInterrupt: pass