def setup_flowgraph(self, mode, ber_skipbytes=0): # parameters self.dp.set_mode(mode) self.rp.set_mode(mode) self.vlen = self.dp.num_carriers/4 self.ber_skipbytes = ber_skipbytes # trigger signals frame_trigger = [1]+[0]*(self.dp.symbols_per_frame-2) self.frame_start = frame_trigger*(len(self.random_bytes)/(self.vlen*(self.dp.symbols_per_frame-1)))+frame_trigger[0:(len(self.random_bytes)/self.vlen)%(self.dp.symbols_per_frame-1)] # sources/sinks self.source = gr.vector_source_b(self.random_bytes, False) self.trig = gr.vector_source_b(self.frame_start, False) if self.ber_sink: self.sink = dab.blocks.measure_ber_b() else: self.sink = gr.vector_sink_b() self.trig_sink = gr.null_sink(gr.sizeof_char) # self.noise_start = gr.noise_source_c(gr.GR_GAUSSIAN, math.sqrt(2), random.randint(0,10000)) # self.noise_start_head = gr.head(gr.sizeof_gr_complex, NOISE_SAMPLES_AT_START) # self.noise_end = gr.noise_source_c(gr.GR_GAUSSIAN, math.sqrt(2), random.randint(0,10000)) # self.noise_end_head = gr.head(gr.sizeof_gr_complex, NOISE_SAMPLES_AT_END) # blocks self.s2v = gr.stream_to_vector(gr.sizeof_char, self.vlen) self.v2s = gr.vector_to_stream(gr.sizeof_char, self.vlen) if self.ber_sink: self.ber_skipbytes0 = gr.skiphead(gr.sizeof_char, self.ber_skipbytes) self.ber_skipbytes1 = gr.skiphead(gr.sizeof_char, self.ber_skipbytes+self.dp.bytes_per_frame) # more blocks (they have state, so better reinitialise them) self.mod = dab.ofdm_mod(self.dp, debug = False) self.rescale = gr.multiply_const_cc(1) self.amp = gr.multiply_const_cc(1) self.channel = blks2.channel_model(noise_voltage=0, noise_seed=random.randint(0,10000)) # self.cat = dab.concatenate_signals(gr.sizeof_gr_complex) self.demod = dab.ofdm_demod(self.dp, self.rp, debug = False, verbose = True) # connect it all if self.ber_sink: self.connect(self.source, self.s2v, (self.mod,0), self.rescale, self.amp, self.channel, (self.demod,0), self.v2s, self.ber_skipbytes0, self.sink) self.connect(self.source, self.ber_skipbytes1, (self.sink,1)) else: self.connect(self.source, self.s2v, (self.mod,0), self.rescale, self.amp, self.channel, (self.demod,0), self.v2s, self.sink) self.connect(self.trig, (self.mod,1)) self.connect((self.demod, 1), self.trig_sink) # SNR calculation and prober self.probe_signal = gr.probe_avg_mag_sqrd_c(0,0.00001) self.probe_total = gr.probe_avg_mag_sqrd_c(0,0.00001) self.connect(self.amp, self.probe_signal) self.connect(self.channel, self.probe_total)
def __init__(self, rx_callback, options):
gr.hier_block2.__init__(
self, "receive_path", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0, 0, 0)
)
options = copy.copy(options) # make a copy so we can destructively modify
self._verbose = options.verbose
self._log = options.log
self._rx_callback = rx_callback # this callback is fired when there's a packet available
coder = None
if options.rs_n and options.rs_k:
if module_exists("reedsolomon"):
print "INIT REED SOLOMON WITH " + str(options.rs_n) + "/" + str(options.rs_k)
import reedsolomon
coder = reedsolomon.Codec(options.rs_n, options.rs_k)
# receiver
self.ofdm_rx = ofdm_demod(options, callback=self._rx_callback, coder=coder)
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
self.probe = gr.probe_avg_mag_sqrd_c(thresh, alpha)
self.connect(self, self.ofdm_rx)
self.connect(self.ofdm_rx, self.probe)
# Display some information about the setup
if self._verbose:
self._print_verbage()
def __init__(self, rx_callback, fwd_callback, options):
gr.hier_block2.__init__(self, "receive_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
options = copy.copy(options) # make a copy so we can destructively modify
self._verbose = options.verbose
self._log = options.log
self._rx_callback = rx_callback # this callback is fired when there's a packet available
self.fwd_callback = fwd_callback
# receiver
self.ofdm_rx = digital.ofdm_demod(options,
callback=self._rx_callback, fwd_callback = self.fwd_callback)
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
self.probe = gr.probe_avg_mag_sqrd_c(thresh,alpha)
self.connect(self, self.ofdm_rx)
self.connect(self.ofdm_rx, self.probe)
# Display some information about the setup
if self._verbose:
self._print_verbage()
def __init__(self,options):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
#CHANGE ME
self.cog_phy_0=phy.cog_phy(options.args)
# dest_addt,source_addr,max_attempts,time_out
#self.probe_0=probe.probe(0,1)
self.probe_0=gr.probe_avg_mag_sqrd_c(-30)
#self.ss_chain_0=spectrum_sense.pwrfft_c(200e3,1024,25,)
self.mac_0=csma.csma_mac(options.dest_addr,options.source_addr,options.max_attempts,options.time_out,0.05,0.0001,10000,self.probe_0,1e-6)
self.wake_up=heart_beat.heart_beat("check","wake_up",0.001)
#CHANGE ME
print options.input_file
self.gr_file_source_0 = gr.file_source(gr.sizeof_char*1,options.input_file, True)
#CHANGE ME
self.gr_file_sink_0 = gr.file_sink(gr.sizeof_char*1, options.output_file)
self.gr_file_sink_0.set_unbuffered(True)
self.extras_stream_to_datagram_0 = grextras.Stream2Datagram(1, options.pkt_size)
self.extras_datagram_to_stream_0 = grextras.Datagram2Stream(1)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.GetWin(),
baseband_freq=990e6,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=1e6,
fft_size=1024,
fft_rate=15,
average=False,
avg_alpha=None,
title="FFT Plot of source usrp",
peak_hold=True,
)
#self.Add(self.wxgui_fftsink2_0.win)
#self.tags_d_0=tags_demo.tags_demo()
#self.extras_stream_to_datagram_1 = grextras.Stream2Datagram(1, 256)
#self.extras_datagram_to_stream_1 = grextras.Datagram2Stream(1)
##################################################
# Connections
##################################################
self.connect((self.gr_file_source_0, 0), (self.extras_stream_to_datagram_0, 0))
self.connect((self.extras_stream_to_datagram_0,0),(self.mac_0,1))
self.connect((self.cog_phy_0,0),(self.mac_0,0))
self.connect((self.mac_0,0),(self.cog_phy_0,0))
self.connect((self.mac_0,1),(self.extras_datagram_to_stream_0,0))
self.connect((self.extras_datagram_to_stream_0,0),(self.gr_file_sink_0,0))
#self.connect((self.cog_phy_0,1),(self.wxgui_fftsink2_0,0))
self.connect((self.wake_up,0),(self.mac_0,2))
#self.connect((self.cog_phy_0,1),(self.mac_0,3))
self.connect((self.cog_phy_0,1),(self.probe_0,0))
"""self.connect((self.gr_file_source_1, 0), (self.extras_stream_to_datagram_1, 0))
def __init__(self, rx_callback, options):
gr.hier_block2.__init__(self, "receive_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(0, 0, 0)) # Output signature
options = copy.copy(options) # make a copy so we can destructively modify
self._verbose = options.verbose
self._log = options.log
self._rx_callback = rx_callback # this callback is fired when there's a packet available
# receiver
self.ofdm_rx = \
blks2.ofdm_demod(options, callback=self._rx_callback)
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
self.probe = gr.probe_avg_mag_sqrd_c(thresh,alpha)
self.connect(self, self.ofdm_rx)
self.connect(self.ofdm_rx, self.probe)
# Display some information about the setup
if self._verbose:
self._print_verbage()
def __init__(self, demod_class, rx_callback, options):
gr.hier_block2.__init__(self, "receive_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
options = copy.copy(options) # make a copy so we can destructively modify
self._verbose = options.verbose
self._bitrate = options.bitrate # desired bit rate
self._rx_callback = rx_callback # this callback is fired when a packet arrives
self._demod_class = demod_class # the demodulator_class we're using
self._chbw_factor = options.chbw_factor # channel filter bandwidth factor
# Get demod_kwargs
demod_kwargs = self._demod_class.extract_kwargs_from_options(options)
# Build the demodulator
self.demodulator = self._demod_class(**demod_kwargs)
# Make sure the channel BW factor is between 1 and sps/2
# or the filter won't work.
if(self._chbw_factor < 1.0 or self._chbw_factor > self.samples_per_symbol()/2):
sys.stderr.write("Channel bandwidth factor ({0}) must be within the range [1.0, {1}].\n".format(self._chbw_factor, self.samples_per_symbol()/2))
sys.exit(1)
# Design filter to get actual channel we want
sw_decim = 1
chan_coeffs = gr.firdes.low_pass (1.0, # gain
sw_decim * self.samples_per_symbol(), # sampling rate
self._chbw_factor, # midpoint of trans. band
0.5, # width of trans. band
gr.firdes.WIN_HANN) # filter type
self.channel_filter = gr.fft_filter_ccc(sw_decim, chan_coeffs)
# receiver
self.packet_receiver = \
digital.demod_pkts(self.demodulator,
access_code=None,
callback=self._rx_callback,
threshold=-1)
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
self.probe = gr.probe_avg_mag_sqrd_c(thresh,alpha)
# Display some information about the setup
if self._verbose:
self._print_verbage()
# connect block input to channel filter
self.connect(self, self.channel_filter)
# connect the channel input filter to the carrier power detector
self.connect(self.channel_filter, self.probe)
# connect channel filter to the packet receiver
self.connect(self.channel_filter, self.packet_receiver)
def _setup_top_block(self):
self.tb = gr.top_block()
samp_rate = 96000
oversample = 10
center_freq = 868.280e6
# Radio receiver, initial downsampling
args = str("nchan=1 rtl=%s,buffers=16,offset_tune=1" % self.device)
osmosdr_source = osmosdr.source_c(args=args)
osmosdr_source.set_sample_rate(samp_rate*oversample)
osmosdr_source.set_center_freq(center_freq, 0)
osmosdr_source.set_freq_corr(0, 0)
osmosdr_source.set_gain_mode(1, 0)
osmosdr_source.set_gain(0, 0)
low_pass_filter = gr.fir_filter_ccf(oversample,
firdes.low_pass(1, samp_rate*oversample, 90e3, 8e3, firdes.WIN_HAMMING, 6.76))
self.tb.connect((osmosdr_source, 0), (low_pass_filter, 0))
# Squelch
self.noise_probe = gr.probe_avg_mag_sqrd_c(0, 1.0/samp_rate/1e2)
self.squelch = gr.simple_squelch_cc(self.noise_level, 1)
noise_probe_thread = threading.Thread(target=self._noise_probe_thread)
noise_probe_thread.start()
self.threads.append(noise_probe_thread)
self.tb.connect((low_pass_filter, 0), (self.noise_probe, 0))
self.tb.connect((low_pass_filter, 0), (self.squelch, 0))
# FM demodulation
quadrature_demod = gr.quadrature_demod_cf(1)
self.tb.connect((self.squelch, 0), (quadrature_demod, 0))
# Binary slicing, transformation into capture-compatible format
add_offset = gr.add_const_vff((-1e-3, ))
binary_slicer = digital.binary_slicer_fb()
char_to_float = gr.char_to_float(1, 1)
multiply_const = gr.multiply_const_vff((255, ))
float_to_uchar = gr.float_to_uchar()
pipe_sink = gr.file_sink(gr.sizeof_char*1, self.pipe)
pipe_sink.set_unbuffered(False)
self.tb.connect((quadrature_demod, 0), (add_offset, 0))
self.tb.connect((add_offset, 0), (binary_slicer, 0))
self.tb.connect((binary_slicer, 0), (char_to_float, 0))
self.tb.connect((char_to_float, 0), (multiply_const, 0))
self.tb.connect((multiply_const, 0), (float_to_uchar, 0))
self.tb.connect((float_to_uchar, 0), (pipe_sink, 0))
def __init__(self, demod_class, rx_callback, options):
gr.hier_block2.__init__(
self,
"receive_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(0, 0, 0)) # Output signature
options = copy.copy(
options) # make a copy so we can destructively modify
self._verbose = options.verbose
self._bitrate = options.bitrate # desired bit rate
self._samples_per_symbol = options.samples_per_symbol # desired samples/symbol
self._rx_callback = rx_callback # this callback is fired when there's a packet available
self._demod_class = demod_class # the demodulator_class we're using
# Get demod_kwargs
demod_kwargs = self._demod_class.extract_kwargs_from_options(options)
# Design filter to get actual channel we want
sw_decim = 1
chan_coeffs = gr.firdes.low_pass(
1.0, # gain
sw_decim * self._samples_per_symbol, # sampling rate
1.0, # midpoint of trans. band
0.5, # width of trans. band
gr.firdes.WIN_HANN) # filter type
self.channel_filter = gr.fft_filter_ccc(sw_decim, chan_coeffs)
# receiver
self.packet_receiver = \
blks2.demod_pkts(self._demod_class(**demod_kwargs),
access_code=None,
callback=self._rx_callback,
threshold=-1)
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
self.probe = gr.probe_avg_mag_sqrd_c(thresh, alpha)
# Display some information about the setup
if self._verbose:
self._print_verbage()
# connect block input to channel filter
self.connect(self, self.channel_filter)
# connect the channel input filter to the carrier power detector
self.connect(self.channel_filter, self.probe)
# connect channel filter to the packet receiver
self.connect(self.channel_filter, self.packet_receiver)
def __init__(self, demod_class, rx_callback, options):
gr.hier_block2.__init__(
self,
"receive_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(0, 0, 0),
) # Output signature
options = copy.copy(options) # make a copy so we can destructively modify
self._verbose = options.verbose
self._bitrate = options.bitrate # desired bit rate
self._samples_per_symbol = options.samples_per_symbol # desired samples/symbol
self._rx_callback = rx_callback # this callback is fired when there's a packet available
self._demod_class = demod_class # the demodulator_class we're using
# Get demod_kwargs
demod_kwargs = self._demod_class.extract_kwargs_from_options(options)
# Design filter to get actual channel we want
sw_decim = 1
chan_coeffs = gr.firdes.low_pass(
1.0, # gain
sw_decim * self._samples_per_symbol, # sampling rate
1.0, # midpoint of trans. band
0.5, # width of trans. band
gr.firdes.WIN_HANN,
) # filter type
self.channel_filter = gr.fft_filter_ccc(sw_decim, chan_coeffs)
# receiver
self.packet_receiver = blks22.demod_pkts(
self._demod_class(**demod_kwargs), access_code=None, callback=self._rx_callback, threshold=-1
)
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
self.probe = gr.probe_avg_mag_sqrd_c(thresh, alpha)
# Display some information about the setup
if self._verbose:
self._print_verbage()
# connect block input to channel filter
self.connect(self, self.channel_filter)
# connect the channel input filter to the carrier power detector
self.connect(self.channel_filter, self.probe)
# connect channel filter to the packet receiver
self.connect(self.channel_filter, self.packet_receiver)
def __init__(self, principal_gui, rx_callback, options):
gr.hier_block2.__init__(self, "receive_path",
gr.io_signature(0,0,0), # the 1,1 indicate the minimum, maximum stream in input
gr.io_signature(0,0,0)) # the 0,0 indicate the minimum, maximum stream in output
#local setup usrp source creat self.usrp source
self._setup_usrp_source(options)
options = copy.copy(options) # Make copy of the received options
self._verbose = options.verbose
self._bitrate = options.rate # The bit rate transmission
self._samples_per_symbol= options.samples_per_symbol # samples/sample
self._rx_callback = rx_callback #This callback is fired (declanche) when there's packet is available
self.demodulator = bpsk_demodulator(principal_gui, options) #The demodulator used
#Designe filter to get actual channel we want
sw_decim = 1
#Create the low pass filter
chan_coeffs = gr.firdes.low_pass (1.0, #gain
sw_decim * self._samples_per_symbol, #sampling rate
1.0, #midpoint of trans band
0.5, #width of trans band
gr.firdes.WIN_HAMMING) #filter type
self.channel_filter = gr.fft_filter_ccc(sw_decim, chan_coeffs)
self.packet_receiver = ieee_pkt_receiver.ieee_pkt_receiver_868_915(self,
gui = principal_gui,
demodulator = self.demodulator,
callback = rx_callback,
sps = self._samples_per_symbol,
symbol_rate = self._bitrate,
threshold = -1)
#Carrier Sensing Block (ecoute du canal)
alpha = 0.001
# Carrier Sensing with dB, will have to adjust
thresh = 30
#construct analyser of carrier (c'est un sink)
self.probe = gr.probe_avg_mag_sqrd_c(thresh, alpha)
#display information about the setup
if self._verbose:
self._print_verbage()
#self.squelch = gr.pwr_squelch_cc(50, 1, 0, True)
#connect the input block to channel filter
#connect the blocks with usrp, the self.usrp is created in _setup_usrp_source
self.squelch = gr.pwr_squelch_cc(50, 1, 0, True)
self.connect(self._usrp, self.packet_receiver)
def __init__(self):
gr.top_block.__init__(self, "Magsquared")
##################################################
# Variables
##################################################
self.valdb = 0
self.variable_function_probe_0 = variable_function_probe_0 = 0
self.samp_rate = samp_rate = 125e3
self.gain = gain = 50
self.center_freq = center_freq = 925e6
s = socket.socket()
##################################################
# Blocks
##################################################
def listener():
while True:
c, addr = s.accept()
data = c.recv(1024)
if (data == 'DataRequest'):
c.send("RSS:{0}".format(self.valdb))
c.close()
self.gr_probe_avg_mag_sqrd_x_0 = gr.probe_avg_mag_sqrd_c(0, 1e-3)
def _variable_function_probe_0_probe():
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
if len(sys.argv) == 3:
host = sys.argv[1]
port = int(sys.argv[2])
else:
host = "localhost"
port = 5006
s.bind((host, port))
s.listen(5)
serverThread = threading.Thread(target=listener)
serverThread.start()
while True:
val = self.gr_probe_avg_mag_sqrd_x_0.level()
if (val > 0):
self.valdb = 10 * math.log10(val)
print self.valdb
try:
self.set_variable_function_probe_0(val)
except AttributeError, e:
pass
time.sleep(1.0 / (7))
def __init__(self, options):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
#CHANGE ME
self.cog_phy_0 = phy.cog_phy(options.args)
self.probe_0 = gr.probe_avg_mag_sqrd_c(30, 0.001)
# dest_addt,source_addr,max_attempts,time_out
self.mac_0 = new_split_tx.split_demo(options.dest_addr,
options.source_addr,
options.time_out, options.lower_H,
options.higher_H, self.probe_0,
1e-3)
#self.mac_0=split.split_demo(options.dest_addr,options.source_addr,options.time_out,options.lower_H,options.higher_H,self.probe_0,1e-8)
self.wake_up = heart_beat.heart_beat("check", "wake_up", 0.01)
#CHANGE ME
self.gr_file_source_0 = gr.file_source(gr.sizeof_char * 1,
options.input_file, True)
#CHANGE ME
self.gr_file_sink_0 = gr.file_sink(gr.sizeof_char * 1,
options.output_file)
self.gr_file_sink_0.set_unbuffered(True)
self.extras_stream_to_datagram_0 = grextras.Stream2Datagram(
1, options.pkt_size)
self.extras_datagram_to_stream_0 = grextras.Datagram2Stream(1)
#self.tags_d_0=tags_demo.tags_demo()
#self.extras_stream_to_datagram_1 = grextras.Stream2Datagram(1, 256)
#self.extras_datagram_to_stream_1 = grextras.Datagram2Stream(1)
##################################################
# Connections
##################################################
self.connect((self.gr_file_source_0, 0),
(self.extras_stream_to_datagram_0, 0))
self.connect((self.extras_stream_to_datagram_0, 0), (self.mac_0, 1))
self.connect((self.cog_phy_0, 0), (self.mac_0, 0))
self.connect((self.mac_0, 0), (self.cog_phy_0, 0))
self.connect((self.mac_0, 1), (self.extras_datagram_to_stream_0, 0))
self.connect((self.extras_datagram_to_stream_0, 0),
(self.gr_file_sink_0, 0))
#self.connect((self.cog_phy_0,1),(self.wxgui_fftsink2_0,0))
self.connect((self.wake_up, 0), (self.mac_0, 2))
self.connect((self.cog_phy_0, 1), (self.probe_0, 0))
#self.connect((self.cog_phy_0,2),(self.wxgui_fftsink2_0,0))
#self.connect((self.cog_phy_0,1),(self.mac_0,3))
#self.connect((self.cog_phy_0,1),(self.tags_d_0,0))
"""self.connect((self.gr_file_source_1, 0), (self.extras_stream_to_datagram_1, 0))
def __init__(self, options, need_padding=False):
gr.hier_block2.__init__(
self, "cs_mac", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(1, 1, gr.sizeof_gr_complex)
)
# Create a logger
self._logger = logging.getLogger("MAC(" + str(options.mac_address) + ")")
# Extract options
self._local_addr = options.mac_address
self._need_padding = need_padding
# Create queue for packets received from physical layer
self._phy_rx_queue = Queue.Queue()
# Create the ack_queue which the condition variable and thread use
self.ack_queue = Queue.Queue()
self.condition = threading.Condition()
# Create physical layer implementation (modulator, demodulator)
self._phy = cs434_hw4_phy.AVAILABLE[options.phy](options, lambda ok, payload: self._handle_recv(ok, payload))
# Received samples are redirected to two places. GNU Radio doesn't
# currently let us attach 2 blocks to a hierarchical block input, so
# we first copy, then split.
rx_dup = gr.kludge_copy(gr.sizeof_gr_complex)
self.connect(self, rx_dup)
# Create and connect carrier-sensing block
self._phy_rx_probe = gr.probe_avg_mag_sqrd_c(options.cs_threshold, 0.001)
self.connect(rx_dup, self._phy_rx_probe)
# Construct receive chain: received packets are delivered via callback from PHY
self.connect(rx_dup, self._phy)
# For certain settings, we may need to 'pad' our
# transmissions with a 0-powered signal when we
# aren't actively transmitting a packet
if need_padding:
import cs434_hw4
self._phy_tx_padder = cs434_hw4.channel_runner_cc()
else:
self._phy_tx_padder = gr.kludge_copy(gr.sizeof_gr_complex)
# Construct transmit chain: packets are delivered to PHY via 'send_pkt()' method
self._phy_tx_scale = gr.multiply_const_cc(options.tx_amplitude)
self.connect(self._phy, self._phy_tx_scale, self._phy_tx_padder, self)
def __init__(self,options):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
#CHANGE ME
self.cog_phy_0=phy.cog_phy(options.args)
# dest_addt,source_addr,max_attempts,time_out
self.probe_0=gr.probe_avg_mag_sqrd_c(30,0.001)
self.mac_0=new_split_rcv.pilot_rcv(options.dest_addr,options.source_addr,self.probe_0,0.05)
self.wake_up=heart_beat.heart_beat("check","wake_up",0.01)
#CHANGE ME
self.gr_file_source_0 = gr.file_source(gr.sizeof_char*1, options.input_file, True)
#CHANGE ME
self.gr_file_sink_0 = gr.file_sink(gr.sizeof_char*1, options.output_file)
self.gr_file_sink_0.set_unbuffered(True)
self.extras_stream_to_datagram_0 = grextras.Stream2Datagram(1, options.pkt_size)
self.extras_datagram_to_stream_0 = grextras.Datagram2Stream(1)
#self.tags_d_0=tags_demo.tags_demo()
#self.extras_stream_to_datagram_1 = grextras.Stream2Datagram(1, 256)
#self.extras_datagram_to_stream_1 = grextras.Datagram2Stream(1)
##################################################
# Connections
##################################################
self.connect((self.gr_file_source_0, 0), (self.extras_stream_to_datagram_0, 0))
self.connect((self.extras_stream_to_datagram_0,0),(self.mac_0,1))
self.connect((self.cog_phy_0,0),(self.mac_0,0))
self.connect((self.mac_0,0),(self.cog_phy_0,0))
self.connect((self.mac_0,1),(self.extras_datagram_to_stream_0,0))
self.connect((self.extras_datagram_to_stream_0,0),(self.gr_file_sink_0,0))
#self.connect((self.cog_phy_0,1),(self.wxgui_fftsink2_0,0))
self.connect((self.wake_up,0),(self.mac_0,2))
self.connect((self.cog_phy_0,1),(self.probe_0,0))
#self.connect((self.cog_phy_0,2),(self.wxgui_fftsink2_0,0))
#self.connect((self.cog_phy_0,1),(self.mac_0,3))
#self.connect((self.cog_phy_0,1),(self.tags_d_0,0))
"""self.connect((self.gr_file_source_1, 0), (self.extras_stream_to_datagram_1, 0))
def __init__(self, modulator_class, options):
'''
See below for what options should hold
'''
gr.hier_block2.__init__(self, "transmit_path",
gr.io_signature(0,0,0),
gr.io_signature(1,1,gr.sizeof_gr_complex))
options = copy.copy(options) # make a copy so we can destructively modify
self._verbose = options.verbose
self._tx_amplitude = options.tx_amplitude # digital amplitude sent to USRP
self._bitrate = options.bitrate # desired bit rate
self._modulator_class = modulator_class # the modulator_class we are using
# Get mod_kwargs
mod_kwargs = self._modulator_class.extract_kwargs_from_options(options)
# transmitter
self.modulator = self._modulator_class(**mod_kwargs)
self.packet_transmitter = \
digital.mod_pkts(self.modulator,
access_code=None,
msgq_limit=4,
pad_for_usrp=True)
self.amp = gr.multiply_const_cc(1)
self.set_tx_amplitude(self._tx_amplitude)
# Figure out how to calculate symbol_rate later
symbol_rate = 5000000
# Hardcoding rx_freq and rx_gain
self.source = uhd_receiver(options.args, symbol_rate,
options.samples_per_symbol,
options.tx_freq-1250000, 30,
options.spec, options.antenna,
options.verbose)
options.samples_per_symbol = self.source._sps
# Display some information about the setup
if self._verbose:
self._print_verbage()
low_pass_taps = [
-0.0401,
0.0663,
0.0468,
-0.0235,
-0.0222,
0.0572,
0.0299,
-0.1001,
-0.0294,
0.3166,
0.5302,
0.3166,
-0.0294,
-0.1001,
0.0299,
0.0572,
-0.0222,
-0.0235,
0.0468,
0.0663,
-0.0401]
high_pass_taps = [
-0.0389,
-0.0026,
0.0302,
0.0181,
-0.0357,
-0.0394,
0.0450,
0.0923,
-0.0472,
-0.3119,
0.5512,
-0.3119,
-0.0472,
0.0923,
0.0450,
-0.0394,
-0.0357,
0.0181,
0.0302,
-0.0026,
-0.0389]
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
self.probe_lp = gr.probe_avg_mag_sqrd_c(thresh,alpha)
self.probe_hp = gr.probe_avg_mag_sqrd_c(thresh,alpha)
self.lp = gr.fft_filter_ccc(65536, low_pass_taps)
self.hp = gr.fft_filter_ccc(65536, high_pass_taps)
self.connect(self.source, self.lp)
self.connect(self.lp, self.probe_lp)
self.connect(self.source, self.hp)
self.connect(self.hp, self.probe_hp)
# Connect components in the flowgraph
self.connect(self.packet_transmitter, self.amp, self)
def __init__(self, demod_class, rx_callback, options):
gr.hier_block2.__init__(self, "receive_path",
gr.io_signature(0, 0, 0), # Input signature
gr.io_signature(0, 0, 0)) # Output signature
options = copy.copy(options) # make a copy so we can destructively modify
self._verbose = options.verbose
self._rx_freq = options.rx_freq # receiver's center frequency
self._rx_gain = options.rx_gain # receiver's gain
self._rx_subdev_spec = options.rx_subdev_spec # daughterboard to use
self._bitrate = options.bitrate # desired bit rate
self._decim = options.decim # Decimating rate for the USRP (prelim)
self._samples_per_symbol = options.samples_per_symbol # desired samples/symbol
self._fusb_block_size = options.fusb_block_size # usb info for USRP
self._fusb_nblocks = options.fusb_nblocks # usb info for USRP
self._rx_callback = rx_callback # this callback is fired when there's a packet available
self._demod_class = demod_class # the demodulator_class we're using
if self._rx_freq is None:
sys.stderr.write("-f FREQ or --freq FREQ or --rx-freq FREQ must be specified\n")
raise SystemExit
# Set up USRP source; also adjusts decim, samples_per_symbol, and bitrate
self._setup_usrp_source()
g = self.subdev.gain_range()
if options.show_rx_gain_range:
print "Rx Gain Range: minimum = %g, maximum = %g, step size = %g" \
% (g[0], g[1], g[2])
self.set_gain(options.rx_gain)
self.set_auto_tr(True) # enable Auto Transmit/Receive switching
# Set RF frequency
ok = self.set_freq(self._rx_freq)
if not ok:
print "Failed to set Rx frequency to %s" % (eng_notation.num_to_str(self._rx_freq))
raise ValueError, eng_notation.num_to_str(self._rx_freq)
# copy the final answers back into options for use by demodulator
options.samples_per_symbol = self._samples_per_symbol
options.bitrate = self._bitrate
options.decim = self._decim
# Get demod_kwargs
demod_kwargs = self._demod_class.extract_kwargs_from_options(options)
# Design filter to get actual channel we want
sw_decim = 1
chan_coeffs = gr.firdes.low_pass (1.0, # gain
sw_decim * self._samples_per_symbol, # sampling rate
1.0, # midpoint of trans. band
0.5, # width of trans. band
gr.firdes.WIN_HANN) # filter type
# Decimating channel filter
# complex in and out, float taps
self.chan_filt = gr.fft_filter_ccc(sw_decim, chan_coeffs)
#self.chan_filt = gr.fir_filter_ccf(sw_decim, chan_coeffs)
# receiver
self.packet_receiver = \
blks2.demod_pkts(self._demod_class(**demod_kwargs),
access_code=None,
callback=self._rx_callback,
threshold=-1)
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
self.sequelcher = gr.simple_squelch_cc(45)
if options.log_rx_power == True:
self.probe = gr.probe_avg_mag_sqrd_cf(thresh,alpha)
self.power_sink = gr.file_sink(gr.sizeof_float, "rxpower.dat")
self.connect(self.chan_filt, self.probe, self.power_sink)
else:
self.probe = gr.probe_avg_mag_sqrd_c(thresh,alpha)
#self.connect(self.chan_filt, self.sequelcher, self.probe)
# Display some information about the setup
if self._verbose:
self._print_verbage()
#filter the noise and pass only the transmitted data
#file_source = gr.file_source(gr.sizeof_gr_complex,"modulated_data.dat")
#self.connect(self.chan_filt,file_sink)
self.connect(self.u, self.chan_filt,self.sequelcher, self.packet_receiver)
def setup_flowgraph(self, mode, ber_skipbytes=0):
# parameters
self.dp.set_mode(mode)
self.rp.set_mode(mode)
self.vlen = self.dp.num_carriers / 4
self.ber_skipbytes = ber_skipbytes
# trigger signals
frame_trigger = [1] + [0] * (self.dp.symbols_per_frame - 2)
self.frame_start = frame_trigger * (
len(self.random_bytes) / (self.vlen *
(self.dp.symbols_per_frame - 1))
) + frame_trigger[0:(len(self.random_bytes) / self.vlen) %
(self.dp.symbols_per_frame - 1)]
# sources/sinks
self.source = gr.vector_source_b(self.random_bytes, False)
self.trig = gr.vector_source_b(self.frame_start, False)
if self.ber_sink:
self.sink = grdab.blocks.measure_ber_b()
else:
self.sink = gr.vector_sink_b()
# self.noise_start = gr.noise_source_c(gr.GR_GAUSSIAN, math.sqrt(2), random.randint(0,10000))
# self.noise_start_head = gr.head(gr.sizeof_gr_complex, NOISE_SAMPLES_AT_START)
# self.noise_end = gr.noise_source_c(gr.GR_GAUSSIAN, math.sqrt(2), random.randint(0,10000))
# self.noise_end_head = gr.head(gr.sizeof_gr_complex, NOISE_SAMPLES_AT_END)
# blocks
self.s2v = gr.stream_to_vector(gr.sizeof_char, self.vlen)
self.v2s = gr.vector_to_stream(gr.sizeof_char, self.vlen)
if self.ber_sink:
self.ber_skipbytes0 = gr.skiphead(gr.sizeof_char,
self.ber_skipbytes)
self.ber_skipbytes1 = gr.skiphead(
gr.sizeof_char, self.ber_skipbytes + self.dp.bytes_per_frame)
# more blocks (they have state, so better reinitialise them)
self.mod = grdab.ofdm_mod(self.dp, debug=False)
self.rescale = gr.multiply_const_cc(1)
self.amp = gr.multiply_const_cc(1)
self.channel = blks2.channel_model(noise_voltage=0,
noise_seed=random.randint(0, 10000))
# self.cat = grdab.concatenate_signals(gr.sizeof_gr_complex)
self.demod = grdab.ofdm_demod(self.dp,
self.rp,
debug=False,
verbose=True)
# connect it all
if self.ber_sink:
self.connect(self.source, self.s2v, (self.mod, 0), self.rescale,
self.amp, self.channel, (self.demod, 0), self.v2s,
self.ber_skipbytes0, self.sink)
self.connect(self.source, self.ber_skipbytes1, (self.sink, 1))
else:
self.connect(self.source, self.s2v, (self.mod, 0), self.rescale,
self.amp, self.channel, (self.demod, 0), self.v2s,
self.sink)
self.connect(self.trig, (self.mod, 1))
# SNR calculation and prober
self.probe_signal = gr.probe_avg_mag_sqrd_c(0, 0.00001)
self.probe_total = gr.probe_avg_mag_sqrd_c(0, 0.00001)
self.connect(self.amp, self.probe_signal)
self.connect(self.channel, self.probe_total)
def __init__(self, options):
gr.top_block.__init__(self)
options = copy.copy(options)
symbol_rate = 2500000
print "%f" % (options.tx_freq-1.25e6)
#print "==========================================\n"
#print "Samp per sym = %d\n" % options.samples_per_symbol
#print "==========================================\n"
self.source = uhd_receiver(options.args, symbol_rate,
1, #options.samples_per_symbol,
options.tx_freq-1.25e6, 30,
options.spec, options.antenna,
options.verbose)
low_pass_taps = [
-0.0401,
0.0663,
0.0468,
-0.0235,
-0.0222,
0.0572,
0.0299,
-0.1001,
-0.0294,
0.3166,
0.5302,
0.3166,
-0.0294,
-0.1001,
0.0299,
0.0572,
-0.0222,
-0.0235,
0.0468,
0.0663,
-0.0401]
high_pass_taps = [
-0.0389,
-0.0026,
0.0302,
0.0181,
-0.0357,
-0.0394,
0.0450,
0.0923,
-0.0472,
-0.3119,
0.5512,
-0.3119,
-0.0472,
0.0923,
0.0450,
-0.0394,
-0.0357,
0.0181,
0.0302,
-0.0026,
-0.0389]
# Carrier Sensing Blocks
alpha = 0.5
thresh = 30 # in dB, will have to adjust
self.probe_lp = gr.probe_avg_mag_sqrd_c(thresh,alpha)
self.probe_hp = gr.probe_avg_mag_sqrd_c(thresh,alpha)
self.lp = gr.fft_filter_ccc(32, low_pass_taps)
self.hp = gr.fft_filter_ccc(32, high_pass_taps)
self.connect(self.source, self.lp)
self.connect(self.lp, self.probe_lp)
self.connect(self.source, self.hp)
self.connect(self.hp, self.probe_hp)
def __init__(self, demod_class, rx_callback, options, source_block):
gr.hier_block2.__init__(self, "receive_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
options = copy.copy(options) # make a copy so we can destructively modify
self._verbose = options.verbose
self._bitrate = options.bitrate # desired bit rate
self._rx_callback = rx_callback # this callback is fired when a packet arrives
self._demod_class = demod_class # the demodulator_class we're using
self._chbw_factor = options.chbw_factor # channel filter bandwidth factor
# Get demod_kwargs
demod_kwargs = self._demod_class.extract_kwargs_from_options(options)
#Give hooks of usrp to blocks downstream
self.source_block = source_block
#########################################
# Build Blocks
#########################################
# Build the demodulator
self.demodulator = self._demod_class(**demod_kwargs)
# Make sure the channel BW factor is between 1 and sps/2
# or the filter won't work.
if(self._chbw_factor < 1.0 or self._chbw_factor > self.samples_per_symbol()/2):
sys.stderr.write("Channel bandwidth factor ({0}) must be within the range [1.0, {1}].\n".format(self._chbw_factor, self.samples_per_symbol()/2))
sys.exit(1)
# Design filter to get actual channel we want
sw_decim = 1
chan_coeffs = gr.firdes.low_pass (1.0, # gain
sw_decim * self.samples_per_symbol(), # sampling rate
self._chbw_factor, # midpoint of trans. band
0.5, # width of trans. band
gr.firdes.WIN_HANN) # filter type
self.channel_filter = gr.fft_filter_ccc(sw_decim, chan_coeffs)
# receiver
self.packet_receiver = \
digital.demod_pkts(self.demodulator,
access_code=None,
callback=self._rx_callback,
threshold=-1)
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
self.probe = gr.probe_avg_mag_sqrd_c(thresh,alpha)
# Display some information about the setup
if self._verbose:
self._print_verbage()
# More Carrier Sensing with FFT
#self.gr_vector_sink = gr.vector_sink_c(1024)
#self.gr_stream_to_vector = gr.stream_to_vector(gr.sizeof_gr_complex*1, 1024)
#self.gr_head = gr.head(gr.sizeof_gr_complex*1024, 1024)
#self.fft = fft.fft_vcc(1024, True, (window.blackmanharris(1024)), True, 1)
# Parameters
usrp_rate = options.bitrate
self.fft_size = 1024
self.min_freq = 2.4e9-0.75e6
self.max_freq = 2.4e9+0.75e6
self.tune_delay = 0.001
self.dwell_delay = 0.01
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)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# 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))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
#self.freq_step = 0.75 * usrp_rate
#self.min_center_freq = self.min_freq + self.freq_step/2
#nsteps = math.ceil((self.max_freq - self.min_freq) / self.freq_step)
#self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.freq_step = 1.5e6
self.min_center_freq = self.min_freq
nsteps = 1
self.max_center_freq = self.max_freq
self.next_freq = self.min_center_freq
tune_delay = max(0, int(round(self.tune_delay * usrp_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(self.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)
######################################################
# Connect Blocks Together
######################################################
#channel-filter-->Probe_Avg_Mag_Sqrd
# -->Packet_Receiver (Demod Done Here!!)
#
# connect FFT sampler to system
#self.connect(self, self.gr_stream_to_vector, self.fft, self.gr_vector_sink)
# connect block input to channel filter
self.connect(self, self.channel_filter)
# connect the channel input filter to the carrier power detector
self.connect(self.channel_filter, self.probe)
# connect channel filter to the packet receiver
self.connect(self.channel_filter, self.packet_receiver)
# FIXME leave out the log10 until we speed it up
#self.connect(self.u, s2v, fft, c2mag, log, stats)
self.connect(self.channel_filter, s2v, fft, c2mag, stats)
def __init__(self, devid="type=b100", rdsfile="rds_fifo", gain=35.0, freq=101.1e6, xmlport=13777, arate=int(48e3), mute=-15.0, ftune=0, ant="J1", subdev="A:0", ahw="pulse", deemph=75.0e-6, prenames='["UWRF","89.3","950","WEVR"]', prefreqs="[88.715e6,89.3e6,950.735e6,106.317e6]", volume=1.0):
grc_wxgui.top_block_gui.__init__(self, title="Simple FM (Stereo) Receiver")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Parameters
##################################################
self.devid = devid
self.rdsfile = rdsfile
self.gain = gain
self.freq = freq
self.xmlport = xmlport
self.arate = arate
self.mute = mute
self.ftune = ftune
self.ant = ant
self.subdev = subdev
self.ahw = ahw
self.deemph = deemph
self.prenames = prenames
self.prefreqs = prefreqs
self.volume = volume
##################################################
# Variables
##################################################
self.pthresh = pthresh = 350
self.preselect = preselect = eval(prefreqs)[0]
self.pilot_level = pilot_level = 0
self.ifreq = ifreq = freq
self.stpilotdet = stpilotdet = True if (pilot_level > pthresh) else False
self.stereo = stereo = True
self.rf_pwr_lvl = rf_pwr_lvl = 0
self.cur_freq = cur_freq = simple_fm_helper.freq_select(ifreq,preselect)
self.vol = vol = volume
self.variable_static_text_0 = variable_static_text_0 = 10.0*math.log(rf_pwr_lvl+1.0e-11)/math.log(10)
self.tone_med = tone_med = 5
self.tone_low = tone_low = 5
self.tone_high = tone_high = 5
self.stereo_0 = stereo_0 = stpilotdet
self.st_enabled = st_enabled = 1 if (stereo == True and pilot_level > pthresh) else 0
self.squelch_probe = squelch_probe = 0
self.sq_thresh = sq_thresh = mute
self.samp_rate = samp_rate = 250e3
self.rtext_0 = rtext_0 = cur_freq
self.record = record = False
self.rdsrate = rdsrate = 25e3
self.osmo_taps = osmo_taps = firdes.low_pass(1.0,1.00e6,95e3,20e3,firdes.WIN_HAMMING,6.76)
self.mod_reset = mod_reset = 0
self.igain = igain = gain
self.fine = fine = ftune
self.farate = farate = arate
self.dm = dm = deemph
self.discrim_dc = discrim_dc = 0
self.capture_file = capture_file = "capture.wav"
self.asrate = asrate = 125e3
##################################################
# Blocks
##################################################
_sq_thresh_sizer = wx.BoxSizer(wx.VERTICAL)
self._sq_thresh_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_sq_thresh_sizer,
value=self.sq_thresh,
callback=self.set_sq_thresh,
label="Mute Level",
converter=forms.float_converter(),
proportion=0,
)
self._sq_thresh_slider = forms.slider(
parent=self.GetWin(),
sizer=_sq_thresh_sizer,
value=self.sq_thresh,
callback=self.set_sq_thresh,
minimum=-30.0,
maximum=-5.0,
num_steps=40,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_sq_thresh_sizer, 1, 5, 1, 1)
self.input_power = gr.probe_avg_mag_sqrd_c(sq_thresh, 1.0/(samp_rate/10))
self.dc_level = gr.probe_signal_f()
_vol_sizer = wx.BoxSizer(wx.VERTICAL)
self._vol_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_vol_sizer,
value=self.vol,
callback=self.set_vol,
label="Volume",
converter=forms.float_converter(),
proportion=0,
)
self._vol_slider = forms.slider(
parent=self.GetWin(),
sizer=_vol_sizer,
value=self.vol,
callback=self.set_vol,
minimum=0,
maximum=11,
num_steps=110,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_vol_sizer, 0, 3, 1, 1)
_tone_med_sizer = wx.BoxSizer(wx.VERTICAL)
self._tone_med_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_tone_med_sizer,
value=self.tone_med,
callback=self.set_tone_med,
label="1Khz-4Khz",
converter=forms.float_converter(),
proportion=0,
)
self._tone_med_slider = forms.slider(
parent=self.GetWin(),
sizer=_tone_med_sizer,
value=self.tone_med,
callback=self.set_tone_med,
minimum=0,
maximum=10,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_tone_med_sizer, 1, 3, 1, 1)
_tone_low_sizer = wx.BoxSizer(wx.VERTICAL)
self._tone_low_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_tone_low_sizer,
value=self.tone_low,
callback=self.set_tone_low,
label="0-1Khz",
converter=forms.float_converter(),
proportion=0,
)
self._tone_low_slider = forms.slider(
parent=self.GetWin(),
sizer=_tone_low_sizer,
value=self.tone_low,
callback=self.set_tone_low,
minimum=0,
maximum=10,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_tone_low_sizer, 1, 2, 1, 1)
_tone_high_sizer = wx.BoxSizer(wx.VERTICAL)
self._tone_high_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_tone_high_sizer,
value=self.tone_high,
callback=self.set_tone_high,
label="4Khz-15Khz",
converter=forms.float_converter(),
proportion=0,
)
self._tone_high_slider = forms.slider(
parent=self.GetWin(),
sizer=_tone_high_sizer,
value=self.tone_high,
callback=self.set_tone_high,
minimum=0,
maximum=10,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_tone_high_sizer, 1, 4, 1, 1)
def _squelch_probe_probe():
while True:
val = self.input_power.unmuted()
try: self.set_squelch_probe(val)
except AttributeError, e: pass
time.sleep(1.0/(10))
_squelch_probe_thread = threading.Thread(target=_squelch_probe_probe)
_squelch_probe_thread.daemon = True
_squelch_probe_thread.start()
self._record_check_box = forms.check_box(
parent=self.GetWin(),
value=self.record,
callback=self.set_record,
label="Record Audio",
true=True,
false=False,
)
self.GridAdd(self._record_check_box, 2, 2, 1, 1)
self.pilot_probe = gr.probe_signal_f()
_fine_sizer = wx.BoxSizer(wx.VERTICAL)
self._fine_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_fine_sizer,
value=self.fine,
callback=self.set_fine,
label="Fine Tuning",
converter=forms.float_converter(),
proportion=0,
)
self._fine_slider = forms.slider(
parent=self.GetWin(),
sizer=_fine_sizer,
value=self.fine,
callback=self.set_fine,
minimum=-50.0e3,
maximum=50.e03,
num_steps=400,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_fine_sizer, 1, 0, 1, 1)
def _discrim_dc_probe():
while True:
val = self.dc_level.level()
try: self.set_discrim_dc(val)
except AttributeError, e: pass
time.sleep(1.0/(2.5))
_discrim_dc_thread = threading.Thread(target=_discrim_dc_probe)
_discrim_dc_thread.daemon = True
_discrim_dc_thread.start()
self._capture_file_text_box = forms.text_box(
parent=self.GetWin(),
value=self.capture_file,
callback=self.set_capture_file,
label="Record Filename",
converter=forms.str_converter(),
)
self.GridAdd(self._capture_file_text_box, 2, 0, 1, 2)
self.Main = self.Main = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
self.Main.AddPage(grc_wxgui.Panel(self.Main), "L/R")
self.Main.AddPage(grc_wxgui.Panel(self.Main), "FM Demod Spectrum")
self.Add(self.Main)
self.wxgui_waterfallsink2_0 = waterfallsink2.waterfall_sink_c(
self.GetWin(),
baseband_freq=0,
dynamic_range=100,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=512,
fft_rate=15,
average=False,
avg_alpha=None,
title="Waterfall Plot",
)
self.Add(self.wxgui_waterfallsink2_0.win)
self.wxgui_scopesink2_0 = scopesink2.scope_sink_f(
self.Main.GetPage(0).GetWin(),
title="Audio Channels (L and R)",
sample_rate=farate,
v_scale=0,
v_offset=0,
t_scale=0,
ac_couple=False,
xy_mode=False,
num_inputs=2,
trig_mode=gr.gr_TRIG_MODE_AUTO,
y_axis_label="Rel. Audio Level",
)
self.Main.GetPage(0).Add(self.wxgui_scopesink2_0.win)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_f(
self.Main.GetPage(1).GetWin(),
baseband_freq=0,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=asrate,
fft_size=1024,
fft_rate=6,
average=True,
avg_alpha=0.1,
title="FM Demod Spectrum",
peak_hold=False,
)
self.Main.GetPage(1).Add(self.wxgui_fftsink2_0.win)
self._variable_static_text_0_static_text = forms.static_text(
parent=self.GetWin(),
value=self.variable_static_text_0,
callback=self.set_variable_static_text_0,
label="RF Power ",
converter=forms.float_converter(formatter=lambda x: "%4.1f" % x),
)
self.GridAdd(self._variable_static_text_0_static_text, 0, 2, 1, 1)
self._stereo_0_check_box = forms.check_box(
parent=self.GetWin(),
value=self.stereo_0,
callback=self.set_stereo_0,
label="Stereo Detect",
true=True,
false=False,
)
self.GridAdd(self._stereo_0_check_box, 2, 5, 1, 1)
self._stereo_check_box = forms.check_box(
parent=self.GetWin(),
value=self.stereo,
callback=self.set_stereo,
label="Stereo",
true=True,
false=False,
)
self.GridAdd(self._stereo_check_box, 2, 4, 1, 1)
self.rtl2832_source_0 = baz.rtl_source_c(defer_creation=True)
self.rtl2832_source_0.set_verbose(True)
self.rtl2832_source_0.set_vid(0x0)
self.rtl2832_source_0.set_pid(0x0)
self.rtl2832_source_0.set_tuner_name("")
self.rtl2832_source_0.set_default_timeout(0)
self.rtl2832_source_0.set_use_buffer(True)
self.rtl2832_source_0.set_fir_coefficients(([]))
if self.rtl2832_source_0.create() == False: raise Exception("Failed to create RTL2832 Source: rtl2832_source_0")
self.rtl2832_source_0.set_sample_rate(1.0e6)
self.rtl2832_source_0.set_frequency(cur_freq+200e3)
self.rtl2832_source_0.set_auto_gain_mode(False)
self.rtl2832_source_0.set_relative_gain(True)
self.rtl2832_source_0.set_gain(gain)
self._rtext_0_static_text = forms.static_text(
parent=self.GetWin(),
value=self.rtext_0,
callback=self.set_rtext_0,
label="CURRENT FREQUENCY>>",
converter=forms.float_converter(),
)
self.GridAdd(self._rtext_0_static_text, 0, 1, 1, 1)
def _rf_pwr_lvl_probe():
while True:
val = self.input_power.level()
try: self.set_rf_pwr_lvl(val)
except AttributeError, e: pass
time.sleep(1.0/(2))
_rf_pwr_lvl_thread = threading.Thread(target=_rf_pwr_lvl_probe)
_rf_pwr_lvl_thread.daemon = True
_rf_pwr_lvl_thread.start()
self._preselect_chooser = forms.radio_buttons(
parent=self.GetWin(),
value=self.preselect,
callback=self.set_preselect,
label='preselect',
choices=eval(prefreqs),
labels=eval(prenames),
style=wx.RA_HORIZONTAL,
)
self.GridAdd(self._preselect_chooser, 0, 4, 1, 1)
def _pilot_level_probe():
while True:
val = self.pilot_probe.level()
try: self.set_pilot_level(val)
except AttributeError, e: pass
time.sleep(1.0/(5))
_pilot_level_thread = threading.Thread(target=_pilot_level_probe)
_pilot_level_thread.daemon = True
_pilot_level_thread.start()
self.low_pass_filter_3 = gr.fir_filter_fff(1, firdes.low_pass(
3, asrate/500, 10, 3, firdes.WIN_HAMMING, 6.76))
self.low_pass_filter_2 = gr.fir_filter_fff(10, firdes.low_pass(
3, asrate/50, 100, 30, firdes.WIN_HAMMING, 6.76))
self.low_pass_filter_1 = gr.fir_filter_fff(10, firdes.low_pass(
3, asrate/5, 1e3, 200, firdes.WIN_HAMMING, 6.76))
self.low_pass_filter_0 = gr.fir_filter_fff(5, firdes.low_pass(
3, asrate, 10e3, 2e3, firdes.WIN_HAMMING, 6.76))
_igain_sizer = wx.BoxSizer(wx.VERTICAL)
self._igain_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_igain_sizer,
value=self.igain,
callback=self.set_igain,
label="RF Gain",
converter=forms.float_converter(),
proportion=0,
)
self._igain_slider = forms.slider(
parent=self.GetWin(),
sizer=_igain_sizer,
value=self.igain,
callback=self.set_igain,
minimum=0,
maximum=50,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_igain_sizer, 1, 1, 1, 1)
_ifreq_sizer = wx.BoxSizer(wx.VERTICAL)
self._ifreq_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_ifreq_sizer,
value=self.ifreq,
callback=self.set_ifreq,
label="Center Frequency",
converter=forms.float_converter(),
proportion=0,
)
self._ifreq_slider = forms.slider(
parent=self.GetWin(),
sizer=_ifreq_sizer,
value=self.ifreq,
callback=self.set_ifreq,
minimum=88.1e6,
maximum=108.1e6,
num_steps=200,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_ifreq_sizer, 0, 0, 1, 1)
self.gr_wavfile_sink_0 = gr.wavfile_sink("/dev/null" if record == False else capture_file, 2, int(farate), 16)
self.gr_sub_xx_0 = gr.sub_ff(1)
self.gr_single_pole_iir_filter_xx_1 = gr.single_pole_iir_filter_ff(2.5/(asrate/500), 1)
self.gr_single_pole_iir_filter_xx_0 = gr.single_pole_iir_filter_ff(1.0/(asrate/3), 1)
self.gr_multiply_xx_1 = gr.multiply_vff(1)
self.gr_multiply_xx_0_0 = gr.multiply_vff(1)
self.gr_multiply_xx_0 = gr.multiply_vff(1)
self.gr_multiply_const_vxx_3 = gr.multiply_const_vff((3.16e3 if st_enabled else 0, ))
self.gr_multiply_const_vxx_2 = gr.multiply_const_vff((1.0 if st_enabled else 1.414, ))
self.gr_multiply_const_vxx_1_0 = gr.multiply_const_vff((0 if st_enabled else 1, ))
self.gr_multiply_const_vxx_1 = gr.multiply_const_vff((0 if squelch_probe == 0 else 1.0, ))
self.gr_multiply_const_vxx_0_0 = gr.multiply_const_vff((vol*1.5*10.0, ))
self.gr_multiply_const_vxx_0 = gr.multiply_const_vff((vol*1.5*10.0 if st_enabled else 0, ))
self.gr_keep_one_in_n_0 = gr.keep_one_in_n(gr.sizeof_float*1, int(asrate/3))
self.gr_freq_xlating_fir_filter_xxx_0 = gr.freq_xlating_fir_filter_ccc(4, (osmo_taps), 200e3+fine+(-12e3*discrim_dc), 1.0e6)
self.gr_fractional_interpolator_xx_0_0 = gr.fractional_interpolator_ff(0, asrate/farate)
self.gr_fractional_interpolator_xx_0 = gr.fractional_interpolator_ff(0, asrate/farate)
self.gr_fft_filter_xxx_1_0_0 = gr.fft_filter_fff(1, (firdes.band_pass(tone_high/10.0,asrate,3.5e3,15.0e3,5.0e3,firdes.WIN_HAMMING)), 1)
self.gr_fft_filter_xxx_1_0 = gr.fft_filter_fff(1, (firdes.band_pass(tone_med/10.0,asrate,1.0e3,4.0e3,2.0e3,firdes.WIN_HAMMING)), 1)
self.gr_fft_filter_xxx_1 = gr.fft_filter_fff(1, (firdes.low_pass(tone_low/10.0,asrate,1.2e3,500,firdes.WIN_HAMMING)), 1)
self.gr_fft_filter_xxx_0_0_0 = gr.fft_filter_fff(1, (firdes.band_pass(tone_high/10.0,asrate,3.5e3,13.5e3,3.5e3,firdes.WIN_HAMMING)), 1)
self.gr_fft_filter_xxx_0_0 = gr.fft_filter_fff(1, (firdes.band_pass(tone_med/10.0,asrate,1.0e3,4.0e3,2.0e3,firdes.WIN_HAMMING)), 1)
self.gr_fft_filter_xxx_0 = gr.fft_filter_fff(1, (firdes.low_pass(tone_low/10.0,asrate,1.2e3,500,firdes.WIN_HAMMING)), 1)
self.gr_divide_xx_0 = gr.divide_ff(1)
self.gr_agc_xx_1 = gr.agc_cc(1e-2, 0.35, 1.0, 5000)
self.gr_add_xx_2_0 = gr.add_vff(1)
self.gr_add_xx_2 = gr.add_vff(1)
self.gr_add_xx_1 = gr.add_vff(1)
self.gr_add_xx_0 = gr.add_vff(1)
self.gr_add_const_vxx_0 = gr.add_const_vff((1.0e-7, ))
self._dm_chooser = forms.radio_buttons(
parent=self.GetWin(),
value=self.dm,
callback=self.set_dm,
label="FM Deemphasis",
choices=[75.0e-6, 50.0e-6],
labels=["NA", "EU"],
style=wx.RA_HORIZONTAL,
)
self.GridAdd(self._dm_chooser, 0, 5, 1, 1)
self.blks2_wfm_rcv_0 = blks2.wfm_rcv(
quad_rate=samp_rate,
audio_decimation=2,
)
self.blks2_fm_deemph_0_0 = blks2.fm_deemph(fs=farate, tau=deemph)
self.blks2_fm_deemph_0 = blks2.fm_deemph(fs=farate, tau=deemph)
self.band_pass_filter_2_0 = gr.fir_filter_fff(1, firdes.band_pass(
20, asrate, 17.5e3, 17.9e3, 250, firdes.WIN_HAMMING, 6.76))
self.band_pass_filter_2 = gr.fir_filter_fff(1, firdes.band_pass(
10, asrate, 18.8e3, 19.2e3, 350, firdes.WIN_HAMMING, 6.76))
self.band_pass_filter_0_0 = gr.fir_filter_fff(1, firdes.band_pass(
1, asrate, 38e3-(15e3), 38e3+(15e3), 4.0e3, firdes.WIN_HAMMING, 6.76))
self.audio_sink_0 = audio.sink(int(farate), "" if ahw == "Default" else ahw, True)
##################################################
# Connections
##################################################
self.connect((self.gr_add_xx_1, 0), (self.gr_fractional_interpolator_xx_0, 0))
self.connect((self.gr_sub_xx_0, 0), (self.gr_fractional_interpolator_xx_0_0, 0))
self.connect((self.band_pass_filter_0_0, 0), (self.gr_multiply_xx_1, 0))
self.connect((self.gr_multiply_const_vxx_1_0, 0), (self.gr_add_xx_0, 0))
self.connect((self.band_pass_filter_2_0, 0), (self.gr_multiply_xx_0, 0))
self.connect((self.band_pass_filter_2_0, 0), (self.gr_multiply_xx_0, 1))
self.connect((self.gr_multiply_xx_0_0, 0), (self.gr_divide_xx_0, 0))
self.connect((self.gr_divide_xx_0, 0), (self.gr_single_pole_iir_filter_xx_0, 0))
self.connect((self.gr_multiply_xx_0, 0), (self.gr_add_const_vxx_0, 0))
self.connect((self.gr_add_const_vxx_0, 0), (self.gr_divide_xx_0, 1))
self.connect((self.gr_single_pole_iir_filter_xx_0, 0), (self.gr_keep_one_in_n_0, 0))
self.connect((self.gr_keep_one_in_n_0, 0), (self.pilot_probe, 0))
self.connect((self.band_pass_filter_2, 0), (self.gr_multiply_xx_1, 2))
self.connect((self.band_pass_filter_2, 0), (self.gr_multiply_xx_0_0, 0))
self.connect((self.gr_multiply_const_vxx_2, 0), (self.gr_add_xx_1, 0))
self.connect((self.gr_multiply_const_vxx_2, 0), (self.gr_sub_xx_0, 0))
self.connect((self.gr_multiply_const_vxx_3, 0), (self.gr_sub_xx_0, 1))
self.connect((self.gr_multiply_const_vxx_3, 0), (self.gr_add_xx_1, 1))
self.connect((self.gr_fractional_interpolator_xx_0, 0), (self.gr_multiply_const_vxx_0_0, 0))
self.connect((self.gr_fractional_interpolator_xx_0_0, 0), (self.gr_multiply_const_vxx_0, 0))
self.connect((self.band_pass_filter_2, 0), (self.gr_multiply_xx_1, 1))
self.connect((self.gr_multiply_xx_1, 0), (self.gr_fft_filter_xxx_0, 0))
self.connect((self.gr_fft_filter_xxx_1, 0), (self.gr_add_xx_2, 0))
self.connect((self.gr_fft_filter_xxx_1_0, 0), (self.gr_add_xx_2, 1))
self.connect((self.gr_fft_filter_xxx_1_0_0, 0), (self.gr_add_xx_2, 2))
self.connect((self.gr_add_xx_2, 0), (self.gr_multiply_const_vxx_2, 0))
self.connect((self.gr_add_xx_2_0, 0), (self.gr_multiply_const_vxx_3, 0))
self.connect((self.gr_fft_filter_xxx_0, 0), (self.gr_add_xx_2_0, 0))
self.connect((self.gr_fft_filter_xxx_0_0, 0), (self.gr_add_xx_2_0, 1))
self.connect((self.gr_multiply_xx_1, 0), (self.gr_fft_filter_xxx_0_0, 0))
self.connect((self.gr_fft_filter_xxx_0_0_0, 0), (self.gr_add_xx_2_0, 2))
self.connect((self.gr_multiply_xx_1, 0), (self.gr_fft_filter_xxx_0_0_0, 0))
self.connect((self.blks2_fm_deemph_0, 0), (self.gr_multiply_const_vxx_1_0, 0))
self.connect((self.blks2_fm_deemph_0, 0), (self.gr_wavfile_sink_0, 0))
self.connect((self.gr_multiply_const_vxx_1, 0), (self.gr_fft_filter_xxx_1, 0))
self.connect((self.gr_multiply_const_vxx_1, 0), (self.gr_fft_filter_xxx_1_0, 0))
self.connect((self.gr_multiply_const_vxx_1, 0), (self.gr_fft_filter_xxx_1_0_0, 0))
self.connect((self.gr_multiply_const_vxx_1, 0), (self.wxgui_fftsink2_0, 0))
self.connect((self.gr_multiply_const_vxx_0_0, 0), (self.blks2_fm_deemph_0, 0))
self.connect((self.gr_add_xx_0, 0), (self.audio_sink_0, 1))
self.connect((self.gr_multiply_const_vxx_0, 0), (self.blks2_fm_deemph_0_0, 0))
self.connect((self.blks2_fm_deemph_0_0, 0), (self.gr_add_xx_0, 1))
self.connect((self.band_pass_filter_2, 0), (self.gr_multiply_xx_0_0, 1))
self.connect((self.gr_multiply_const_vxx_1, 0), (self.band_pass_filter_2, 0))
self.connect((self.blks2_fm_deemph_0, 0), (self.audio_sink_0, 0))
self.connect((self.gr_multiply_const_vxx_1, 0), (self.band_pass_filter_2_0, 0))
self.connect((self.gr_multiply_const_vxx_1, 0), (self.band_pass_filter_0_0, 0))
self.connect((self.gr_add_xx_0, 0), (self.gr_wavfile_sink_0, 1))
self.connect((self.blks2_fm_deemph_0, 0), (self.wxgui_scopesink2_0, 0))
self.connect((self.gr_add_xx_0, 0), (self.wxgui_scopesink2_0, 1))
self.connect((self.blks2_wfm_rcv_0, 0), (self.gr_multiply_const_vxx_1, 0))
self.connect((self.gr_agc_xx_1, 0), (self.blks2_wfm_rcv_0, 0))
self.connect((self.gr_freq_xlating_fir_filter_xxx_0, 0), (self.gr_agc_xx_1, 0))
self.connect((self.gr_freq_xlating_fir_filter_xxx_0, 0), (self.input_power, 0))
self.connect((self.blks2_wfm_rcv_0, 0), (self.low_pass_filter_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.low_pass_filter_1, 0))
self.connect((self.low_pass_filter_1, 0), (self.low_pass_filter_2, 0))
self.connect((self.low_pass_filter_2, 0), (self.low_pass_filter_3, 0))
self.connect((self.gr_single_pole_iir_filter_xx_1, 0), (self.dc_level, 0))
self.connect((self.low_pass_filter_3, 0), (self.gr_single_pole_iir_filter_xx_1, 0))
self.connect((self.rtl2832_source_0, 0), (self.gr_freq_xlating_fir_filter_xxx_0, 0))
self.connect((self.gr_freq_xlating_fir_filter_xxx_0, 0), (self.wxgui_waterfallsink2_0, 0))
def __init__(self, demod_class, rx_callback, options):
gr.hier_block2.__init__(self, "receive_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
options = copy.copy(
options) # make a copy so we can destructively modify
self._verbose = options.verbose
self._bitrate = options.bitrate # desired bit rate
self._rx_callback = rx_callback # this callback is fired when a packet arrives
self._demod_class = demod_class # the demodulator_class we're using
self._chbw_factor = options.chbw_factor # channel filter bandwidth factor
# Get demod_kwargs
demod_kwargs = self._demod_class.extract_kwargs_from_options(options)
# Build the demodulator
self.demodulator = self._demod_class(**demod_kwargs)
# Make sure the channel BW factor is between 1 and sps/2
# or the filter won't work.
if (self._chbw_factor < 1.0
or self._chbw_factor > self.samples_per_symbol() / 2):
sys.stderr.write(
"Channel bandwidth factor ({0}) must be within the range [1.0, {1}].\n"
.format(self._chbw_factor,
self.samples_per_symbol() / 2))
sys.exit(1)
# Design filter to get actual channel we want
sw_decim = 1
chan_coeffs = gr.firdes.low_pass(
1.0, # gain
sw_decim * self.samples_per_symbol(), # sampling rate
self._chbw_factor, # midpoint of trans. band
0.5, # width of trans. band
gr.firdes.WIN_HANN) # filter type
self.channel_filter = gr.fft_filter_ccc(sw_decim, chan_coeffs)
# receiver
self.packet_receiver = \
digital.demod_pkts(self.demodulator,
access_code=None,
callback=self._rx_callback,
threshold=-1)
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
self.probe = gr.probe_avg_mag_sqrd_c(thresh, alpha)
# Display some information about the setup
if self._verbose:
self._print_verbage()
# connect block input to channel filter
self.connect(self, self.channel_filter)
# connect the channel input filter to the carrier power detector
self.connect(self.channel_filter, self.probe)
# connect channel filter to the packet receiver
self.connect(self.channel_filter, self.packet_receiver)
def __init__(self, rx_callback, options):
gr.hier_block2.__init__(self, "receive_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
options = copy.copy(options) # make a copy so we can destructively modify
self._verbose = options.verbose
self._log = options.log
self._rx_callback = rx_callback # this callback is fired when there's a packet available
self._rcvd_pktq = gr.msg_queue() # holds packets from the PHY
self._modulation = options.modulation
self._fft_length = options.fft_length
self._occupied_tones = options.occupied_tones
self._cp_length = options.cp_length
self._snr = options.snr
# Use freq domain to get doubled-up known symbol for correlation in time domain
zeros_on_left = int(math.ceil((self._fft_length - self._occupied_tones)/2.0))
preamble_sequence = known_symbols_4512_3[0:self._occupied_tones]
training_sequence = ( known_symbols_4512_3[self._occupied_tones:self._occupied_tones*2], \
known_symbols_4512_3[self._occupied_tones*2:self._occupied_tones*3] )
for i in range(len(preamble_sequence)):
if((zeros_on_left + i) & 1):
preamble_sequence[i] = 0
# hard-coded known symbols
preambles = (preamble_sequence,)
symbol_length = self._fft_length + self._cp_length
self.ofdm_recv = ofdm_receiver(self._fft_length,
self._cp_length,
self._occupied_tones,
self._snr,
preambles,
training_sequence,
options.log)
mods = {"bpsk": 2, "qpsk": 4, "8psk": 8, "qam8": 8, "qam16": 16, "qam64": 64, "qam256": 256}
arity = mods[self._modulation]
rot = 1
if self._modulation == "qpsk":
rot = (0.707+0.707j)
# FIXME: pass the constellation objects instead of just the points
if(self._modulation.find("psk") >= 0):
constel = psk.psk_constellation(arity)
rotated_const = map(lambda pt: pt * rot, constel.points())
elif(self._modulation.find("qam") >= 0):
constel = qam.qam_constellation(arity)
rotated_const = map(lambda pt: pt * rot, constel.points())
#print rotated_const
phgain = 0.25
frgain = phgain*phgain / 4.0
self.ofdm_demod = gtlib.ofdm_frame_sink(rotated_const, range(arity),
self._rcvd_pktq,
self._occupied_tones,
phgain, frgain)
"""
# receiver
self.ofdm_rx = ofdm.ofdm_demod(options,
callback=self._rx_callback)
"""
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
self.probe = gr.probe_avg_mag_sqrd_c(thresh,alpha)
self.connect(self, self.ofdm_recv)
self.connect((self.ofdm_recv, 0), (self.ofdm_demod, 0))
self.connect((self.ofdm_recv, 1), (self.ofdm_demod, 1))
# added output signature to work around bug, though it might not be a bad
# thing to export, anyway
self.connect(self.ofdm_recv.chan_filt, self.probe)
if options.log:
self.connect(self.ofdm_demod,
gr.file_sink(gr.sizeof_gr_complex*self._occupied_tones,
"ofdm_frame_sink_c.dat"))
else:
self.connect(self.ofdm_demod,
gr.null_sink(gr.sizeof_gr_complex*self._occupied_tones))
# Display some information about the setup
if self._verbose:
self._print_verbage()
self._watcher = _queue_watcher_thread(self._rcvd_pktq, self._rx_callback)
1.0, # midpoint of trans. band
0.5, # width of trans. band
gr.firdes.WIN_HANN) # filter type
self.channel_filter = gr.fft_filter_ccc(sw_decim, chan_coeffs)
# receiver
self.packet_receiver = \
digital.demod_pkts(self.demodulator,
access_code=None,
callback=self._rx_callback,
threshold=-1)
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
self.probe = gr.probe_avg_mag_sqrd_c(thresh,alpha)
# Display some information about the setup
if self._verbose:
self._print_verbage()
#########################################
# CONNECTIONS
#########################################
# connect block input to channel filter
self.connect(self, self.channel_filter)
# connect the channel input filter to the carrier power detector
self.connect(self.channel_filter, self.probe)
def __init__(self, ahw="default", freq=150.0e6, ppm=0.0, vol=1.0, ftune=0.0, xftune=0.0, srate=1.0e6, upclo=0.0, devinfo="rtl=0", agc=0, arate=48.0e3, upce=0, mthresh=-10.0, offs=50.e3, flist="", dfifo="multimode_fifo", mbw=2.0e3, deemph=75.0e-6, dmode="NFM1"):
grc_wxgui.top_block_gui.__init__(self, title="Multimode Radio Receiver")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Parameters
##################################################
self.ahw = ahw
self.freq = freq
self.ppm = ppm
self.vol = vol
self.ftune = ftune
self.xftune = xftune
self.srate = srate
self.upclo = upclo
self.devinfo = devinfo
self.agc = agc
self.arate = arate
self.upce = upce
self.mthresh = mthresh
self.offs = offs
self.flist = flist
self.dfifo = dfifo
self.mbw = mbw
self.deemph = deemph
self.dmode = dmode
##################################################
# Variables
##################################################
self.sc_list_str = sc_list_str = flist
self.zoom = zoom = 1
self.thresh = thresh = mthresh
self.scan_rate = scan_rate = 15
self.scan_power = scan_power = 0
self.sc_low = sc_low = 150e6
self.sc_listm = sc_listm = False
self.sc_list = sc_list = eval("["+sc_list_str+"]")
self.sc_incr = sc_incr = 12.5e3
self.sc_high = sc_high = 300e6
self.sc_ena = sc_ena = False
self.samp_rate = samp_rate = int(mh.get_good_rate(devinfo,srate))
self.rf_power = rf_power = 0
self.ifreq = ifreq = freq
self.zoomed_lp = zoomed_lp = (samp_rate/2.1)/zoom
self.wbfm = wbfm = 200e3
self.rf_d_power = rf_d_power = 0
self.mode = mode = dmode
self.logpower = logpower = math.log10(rf_power+1.0e-14)*10.0
self.cur_freq = cur_freq = mh.scan_freq_out(sc_ena,sc_low,sc_high,freq,ifreq,scan_power+1.0e-14,thresh,sc_incr,scan_rate,sc_listm,sc_list)
self.bw = bw = mbw
self.audio_int_rate = audio_int_rate = 40e3
self.zoom_taps = zoom_taps = firdes.low_pass(1.0,samp_rate,zoomed_lp,zoomed_lp/3,firdes.WIN_HAMMING,6.76)
self.xfine = xfine = xftune
self.volume = volume = vol
self.variable_static_text_1 = variable_static_text_1 = cur_freq
self.variable_static_text_0_0 = variable_static_text_0_0 = samp_rate
self.variable_static_text_0 = variable_static_text_0 = float(int(math.log10(rf_d_power+1.0e-14)*100.0)/10.0)
self.upc_offset = upc_offset = upclo
self.upc = upc = upce
self.ssbo = ssbo = -bw/2 if mode == "LSB" else 0.0
self.sc_list_len = sc_list_len = len(sc_list)
self.rfgain = rfgain = 25
self.record_file = record_file = "recording.wav"
self.record = record = False
self.offset = offset = offs
self.muted = muted = 0.0 if logpower >= thresh else 1
self.main_taps = main_taps = firdes.low_pass(1.0,wbfm,mh.get_mode_deviation(mode,bw)*1.05,mh.get_mode_deviation(mode,bw)/2.0,firdes.WIN_HAMMING,6.76)
self.k = k = wbfm/(2*math.pi*mh.get_mode_deviation(mode,bw))
self.iagc = iagc = agc
self.freq_update = freq_update = 0
self.fine = fine = ftune
self.digi_rate = digi_rate = 50e3
self.aratio = aratio = int(wbfm/audio_int_rate)
##################################################
# Blocks
##################################################
self.rf_probe = gr.probe_avg_mag_sqrd_c(0, 0.015)
self.Main = self.Main = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
self.Main.AddPage(grc_wxgui.Panel(self.Main), "Main Controls")
self.Main.AddPage(grc_wxgui.Panel(self.Main), "Scan/Upconv Controls")
self.Add(self.Main)
self._zoom_chooser = forms.drop_down(
parent=self.Main.GetPage(0).GetWin(),
value=self.zoom,
callback=self.set_zoom,
label="Spectral Zoom Ratio",
choices=[1, 2, 5, 10, 20, 50, 100],
labels=[],
)
self.Main.GetPage(0).GridAdd(self._zoom_chooser, 1, 4, 1, 1)
_xfine_sizer = wx.BoxSizer(wx.VERTICAL)
self._xfine_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
sizer=_xfine_sizer,
value=self.xfine,
callback=self.set_xfine,
label="Extra Fine Tuning",
converter=forms.float_converter(),
proportion=0,
)
self._xfine_slider = forms.slider(
parent=self.Main.GetPage(0).GetWin(),
sizer=_xfine_sizer,
value=self.xfine,
callback=self.set_xfine,
minimum=-1.0e3,
maximum=1.0e3,
num_steps=200,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Main.GetPage(0).GridAdd(_xfine_sizer, 0, 3, 1, 1)
_volume_sizer = wx.BoxSizer(wx.VERTICAL)
self._volume_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
sizer=_volume_sizer,
value=self.volume,
callback=self.set_volume,
label="Volume",
converter=forms.float_converter(),
proportion=0,
)
self._volume_slider = forms.slider(
parent=self.Main.GetPage(0).GetWin(),
sizer=_volume_sizer,
value=self.volume,
callback=self.set_volume,
minimum=1.0,
maximum=10.0,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Main.GetPage(0).GridAdd(_volume_sizer, 0, 0, 1, 1)
self._upc_offset_text_box = forms.text_box(
parent=self.Main.GetPage(1).GetWin(),
value=self.upc_offset,
callback=self.set_upc_offset,
label="Upconv. LO Freq",
converter=forms.float_converter(),
)
self.Main.GetPage(1).GridAdd(self._upc_offset_text_box, 3, 2, 1, 2)
self._upc_check_box = forms.check_box(
parent=self.Main.GetPage(1).GetWin(),
value=self.upc,
callback=self.set_upc,
label="Ext. Upconv.",
true=1,
false=0,
)
self.Main.GetPage(1).GridAdd(self._upc_check_box, 3, 0, 1, 1)
_rfgain_sizer = wx.BoxSizer(wx.VERTICAL)
self._rfgain_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
sizer=_rfgain_sizer,
value=self.rfgain,
callback=self.set_rfgain,
label="RF Gain",
converter=forms.float_converter(),
proportion=0,
)
self._rfgain_slider = forms.slider(
parent=self.Main.GetPage(0).GetWin(),
sizer=_rfgain_sizer,
value=self.rfgain,
callback=self.set_rfgain,
minimum=0,
maximum=50,
num_steps=200,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Main.GetPage(0).GridAdd(_rfgain_sizer, 2, 1, 1, 1)
self._record_file_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
value=self.record_file,
callback=self.set_record_file,
label="Recording Filename",
converter=forms.str_converter(),
)
self.Main.GetPage(0).GridAdd(self._record_file_text_box, 2, 3, 1, 3)
self._record_check_box = forms.check_box(
parent=self.Main.GetPage(0).GetWin(),
value=self.record,
callback=self.set_record,
label="Record",
true=True,
false=False,
)
self.Main.GetPage(0).GridAdd(self._record_check_box, 2, 2, 1, 1)
_offset_sizer = wx.BoxSizer(wx.VERTICAL)
self._offset_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
sizer=_offset_sizer,
value=self.offset,
callback=self.set_offset,
label="LO Offset",
converter=forms.float_converter(),
proportion=0,
)
self._offset_slider = forms.slider(
parent=self.Main.GetPage(0).GetWin(),
sizer=_offset_sizer,
value=self.offset,
callback=self.set_offset,
minimum=25e3,
maximum=500e3,
num_steps=200,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Main.GetPage(0).GridAdd(_offset_sizer, 1, 3, 1, 1)
self._mode_chooser = forms.drop_down(
parent=self.Main.GetPage(0).GetWin(),
value=self.mode,
callback=self.set_mode,
label="Mode",
choices=mh.get_modes_values(),
labels=mh.get_modes_names(),
)
self.Main.GetPage(0).GridAdd(self._mode_chooser, 0, 4, 1, 1)
self._iagc_check_box = forms.check_box(
parent=self.Main.GetPage(0).GetWin(),
value=self.iagc,
callback=self.set_iagc,
label="AGC",
true=1,
false=0,
)
self.Main.GetPage(0).GridAdd(self._iagc_check_box, 2, 0, 1, 1)
def _freq_update_probe():
while True:
val = self.rf_probe.level()
try: self.set_freq_update(val)
except AttributeError, e: pass
time.sleep(1.0/(1.0/(2.5)))
_freq_update_thread = threading.Thread(target=_freq_update_probe)
_freq_update_thread.daemon = True
_freq_update_thread.start()
_fine_sizer = wx.BoxSizer(wx.VERTICAL)
self._fine_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
sizer=_fine_sizer,
value=self.fine,
callback=self.set_fine,
label="Fine Tuning",
converter=forms.float_converter(),
proportion=0,
)
self._fine_slider = forms.slider(
parent=self.Main.GetPage(0).GetWin(),
sizer=_fine_sizer,
value=self.fine,
callback=self.set_fine,
minimum=-35e3,
maximum=35e3,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Main.GetPage(0).GridAdd(_fine_sizer, 0, 2, 1, 1)
self.display_probe = gr.probe_avg_mag_sqrd_c(0, 0.002)
_bw_sizer = wx.BoxSizer(wx.VERTICAL)
self._bw_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
sizer=_bw_sizer,
value=self.bw,
callback=self.set_bw,
label="AM/SSB Bandwidth",
converter=forms.float_converter(),
proportion=0,
)
self._bw_slider = forms.slider(
parent=self.Main.GetPage(0).GetWin(),
sizer=_bw_sizer,
value=self.bw,
callback=self.set_bw,
minimum=1.0e3,
maximum=audio_int_rate/2,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Main.GetPage(0).GridAdd(_bw_sizer, 1, 2, 1, 1)
self.wxgui_waterfallsink2_0 = waterfallsink2.waterfall_sink_c(
self.Main.GetPage(0).GetWin(),
baseband_freq=mh.get_last_returned(freq_update),
dynamic_range=40,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate/zoom,
fft_size=1024,
fft_rate=4,
average=True,
avg_alpha=None,
title="Spectrogram",
win=window.hamming,
)
self.Main.GetPage(0).Add(self.wxgui_waterfallsink2_0.win)
def wxgui_waterfallsink2_0_callback(x, y):
self.set_freq(x)
self.wxgui_waterfallsink2_0.set_callback(wxgui_waterfallsink2_0_callback)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.Main.GetPage(0).GetWin(),
baseband_freq=mh.get_last_returned(freq_update),
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate/zoom,
fft_size=1024,
fft_rate=4,
average=True,
avg_alpha=0.1,
title="Panorama",
peak_hold=False,
win=window.hamming,
)
self.Main.GetPage(0).Add(self.wxgui_fftsink2_0.win)
def wxgui_fftsink2_0_callback(x, y):
self.set_freq(x)
self.wxgui_fftsink2_0.set_callback(wxgui_fftsink2_0_callback)
self._variable_static_text_1_static_text = forms.static_text(
parent=self.Main.GetPage(1).GetWin(),
value=self.variable_static_text_1,
callback=self.set_variable_static_text_1,
label="Current Scan Freq",
converter=forms.float_converter(),
)
self.Main.GetPage(1).GridAdd(self._variable_static_text_1_static_text, 0, 5, 1, 2)
self._variable_static_text_0_0_static_text = forms.static_text(
parent=self.Main.GetPage(0).GetWin(),
value=self.variable_static_text_0_0,
callback=self.set_variable_static_text_0_0,
label="Actual srate",
converter=forms.float_converter(),
)
self.Main.GetPage(0).GridAdd(self._variable_static_text_0_0_static_text, 1, 5, 1, 1)
self._variable_static_text_0_static_text = forms.static_text(
parent=self.Main.GetPage(0).GetWin(),
value=self.variable_static_text_0,
callback=self.set_variable_static_text_0,
label="RF Level",
converter=forms.float_converter(),
)
self.Main.GetPage(0).GridAdd(self._variable_static_text_0_static_text, 1, 0, 1, 1)
_thresh_sizer = wx.BoxSizer(wx.VERTICAL)
self._thresh_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
sizer=_thresh_sizer,
value=self.thresh,
callback=self.set_thresh,
label="Mute Threshold",
converter=forms.float_converter(),
proportion=0,
)
self._thresh_slider = forms.slider(
parent=self.Main.GetPage(0).GetWin(),
sizer=_thresh_sizer,
value=self.thresh,
callback=self.set_thresh,
minimum=-50,
maximum=10,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Main.GetPage(0).GridAdd(_thresh_sizer, 1, 1, 1, 1)
def _scan_power_probe():
while True:
val = self.rf_probe.level()
try: self.set_scan_power(val)
except AttributeError, e: pass
time.sleep(1.0/(scan_rate))
_scan_power_thread = threading.Thread(target=_scan_power_probe)
_scan_power_thread.daemon = True
_scan_power_thread.start()
self._sc_low_text_box = forms.text_box(
parent=self.Main.GetPage(1).GetWin(),
value=self.sc_low,
callback=self.set_sc_low,
label="Scan Low",
converter=forms.float_converter(),
)
self.Main.GetPage(1).GridAdd(self._sc_low_text_box, 0, 1, 1, 1)
self._sc_listm_check_box = forms.check_box(
parent=self.Main.GetPage(1).GetWin(),
value=self.sc_listm,
callback=self.set_sc_listm,
label="Scan List Mode",
true=True,
false=False,
)
self.Main.GetPage(1).GridAdd(self._sc_listm_check_box, 2, 0, 1, 1)
self._sc_list_str_text_box = forms.text_box(
parent=self.Main.GetPage(1).GetWin(),
value=self.sc_list_str,
callback=self.set_sc_list_str,
label="Scan List",
converter=forms.str_converter(),
)
self.Main.GetPage(1).GridAdd(self._sc_list_str_text_box, 2, 1, 1, 5)
self._sc_incr_chooser = forms.drop_down(
parent=self.Main.GetPage(1).GetWin(),
value=self.sc_incr,
callback=self.set_sc_incr,
label="Scan Increment (Hz)",
choices=[5.0e3,6.25e3,10.0e3,12.5e3,15e3,25e3],
labels=[],
)
self.Main.GetPage(1).GridAdd(self._sc_incr_chooser, 0, 0, 1, 1)
self._sc_high_text_box = forms.text_box(
parent=self.Main.GetPage(1).GetWin(),
value=self.sc_high,
callback=self.set_sc_high,
label="Scan High",
converter=forms.float_converter(),
)
self.Main.GetPage(1).GridAdd(self._sc_high_text_box, 0, 2, 1, 1)
self._sc_ena_check_box = forms.check_box(
parent=self.Main.GetPage(1).GetWin(),
value=self.sc_ena,
callback=self.set_sc_ena,
label="Scan Enable",
true=True,
false=False,
)
self.Main.GetPage(1).GridAdd(self._sc_ena_check_box, 0, 3, 1, 1)
def _rf_power_probe():
while True:
val = self.rf_probe.level()
try: self.set_rf_power(val)
except AttributeError, e: pass
time.sleep(1.0/(10))
_rf_power_thread = threading.Thread(target=_rf_power_probe)
_rf_power_thread.daemon = True
_rf_power_thread.start()
def _rf_d_power_probe():
while True:
val = self.display_probe.level()
try: self.set_rf_d_power(val)
except AttributeError, e: pass
time.sleep(1.0/(5))
_rf_d_power_thread = threading.Thread(target=_rf_d_power_probe)
_rf_d_power_thread.daemon = True
_rf_d_power_thread.start()
self.osmosdr_source_c_0 = osmosdr.source_c( args="nchan=" + str(1) + " " + devinfo )
self.osmosdr_source_c_0.set_sample_rate(samp_rate)
self.osmosdr_source_c_0.set_center_freq(cur_freq+offset+(upc_offset*float(upc)), 0)
self.osmosdr_source_c_0.set_freq_corr(ppm, 0)
self.osmosdr_source_c_0.set_gain_mode(iagc, 0)
self.osmosdr_source_c_0.set_gain(25 if iagc == 1 else rfgain, 0)
self.osmosdr_source_c_0.set_if_gain(20, 0)
self._ifreq_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
value=self.ifreq,
callback=self.set_ifreq,
label="Frequency",
converter=forms.float_converter(),
)
self.Main.GetPage(0).GridAdd(self._ifreq_text_box, 0, 1, 1, 1)
self.gr_wavfile_sink_0 = gr.wavfile_sink("/dev/null" if record == False else record_file, 1, int(audio_int_rate), 8)
self.gr_quadrature_demod_cf_0 = gr.quadrature_demod_cf(k)
self.gr_multiply_const_vxx_2 = gr.multiply_const_vff((1.0 if mh.get_mode_type(mode) == "FM" else 0.0, ))
self.gr_multiply_const_vxx_1 = gr.multiply_const_vff((0.0 if muted else volume/4.5, ))
self.gr_multiply_const_vxx_0_0_0 = gr.multiply_const_vff((0.85 if mh.get_mode_type(mode) == "AM" else 0.0, ))
self.gr_multiply_const_vxx_0_0 = gr.multiply_const_vff((0.85 if mh.get_mode_type(mode) == "SSB" else 0.0, ))
self.gr_multiply_const_vxx_0 = gr.multiply_const_vcc(((1.0/math.sqrt(mh.get_mode_deviation(mode,bw))*250), ))
self.gr_keep_one_in_n_1 = gr.keep_one_in_n(gr.sizeof_gr_complex*1, aratio)
self.gr_keep_one_in_n_0_0 = gr.keep_one_in_n(gr.sizeof_gr_complex*1, zoom)
self.gr_keep_one_in_n_0 = gr.keep_one_in_n(gr.sizeof_gr_complex*1, int(wbfm/digi_rate))
self.gr_freq_xlating_fir_filter_xxx_0_1 = gr.freq_xlating_fir_filter_ccc(1, (1.0, ), (offset+fine+xfine)/(samp_rate/1.0e6), samp_rate)
self.gr_fractional_interpolator_xx_0 = gr.fractional_interpolator_ff(0, audio_int_rate/arate)
self.gr_file_sink_0 = gr.file_sink(gr.sizeof_gr_complex*1, "/dev/null" if mh.get_mode_type(mode) != "DIG" else dfifo)
self.gr_file_sink_0.set_unbuffered(True)
self.gr_fft_filter_xxx_3 = gr.fft_filter_ccc(1, (zoom_taps), 1)
self.gr_fft_filter_xxx_2_0 = gr.fft_filter_fff(5, (firdes.low_pass(1.0,wbfm,14.5e3,8.5e3,firdes.WIN_HAMMING,6.76)), 1)
self.gr_fft_filter_xxx_2 = gr.fft_filter_ccc(1, (main_taps), 1)
self.gr_fft_filter_xxx_0 = gr.fft_filter_ccc(int(samp_rate/wbfm), (firdes.low_pass(1.0,samp_rate,98.5e3,66e3,firdes.WIN_HAMMING,6.76)), 1)
self.gr_feedforward_agc_cc_0 = gr.feedforward_agc_cc(1024, 0.75)
self.gr_complex_to_real_0 = gr.complex_to_real(1)
self.gr_complex_to_mag_squared_0 = gr.complex_to_mag_squared(1)
self.gr_add_xx_0 = gr.add_vff(1)
self.blks2_fm_deemph_0 = blks2.fm_deemph(fs=audio_int_rate, tau=deemph)
self.audio_sink_0 = audio.sink(int(arate), ahw, True)
##################################################
# Connections
##################################################
self.connect((self.gr_multiply_const_vxx_0_0, 0), (self.gr_add_xx_0, 1))
self.connect((self.gr_fractional_interpolator_xx_0, 0), (self.gr_multiply_const_vxx_1, 0))
self.connect((self.gr_multiply_const_vxx_1, 0), (self.audio_sink_0, 0))
self.connect((self.gr_multiply_const_vxx_1, 0), (self.audio_sink_0, 1))
self.connect((self.gr_feedforward_agc_cc_0, 0), (self.gr_complex_to_mag_squared_0, 0))
self.connect((self.osmosdr_source_c_0, 0), (self.gr_freq_xlating_fir_filter_xxx_0_1, 0))
self.connect((self.gr_multiply_const_vxx_0_0_0, 0), (self.gr_add_xx_0, 2))
self.connect((self.gr_feedforward_agc_cc_0, 0), (self.gr_complex_to_real_0, 0))
self.connect((self.gr_complex_to_real_0, 0), (self.gr_multiply_const_vxx_0_0, 0))
self.connect((self.gr_multiply_const_vxx_2, 0), (self.gr_add_xx_0, 0))
self.connect((self.gr_complex_to_mag_squared_0, 0), (self.gr_multiply_const_vxx_0_0_0, 0))
self.connect((self.gr_multiply_const_vxx_0, 0), (self.display_probe, 0))
self.connect((self.gr_multiply_const_vxx_0, 0), (self.rf_probe, 0))
self.connect((self.gr_add_xx_0, 0), (self.gr_fractional_interpolator_xx_0, 0))
self.connect((self.gr_add_xx_0, 0), (self.gr_wavfile_sink_0, 0))
self.connect((self.gr_freq_xlating_fir_filter_xxx_0_1, 0), (self.gr_fft_filter_xxx_0, 0))
self.connect((self.gr_keep_one_in_n_0, 0), (self.gr_file_sink_0, 0))
self.connect((self.gr_freq_xlating_fir_filter_xxx_0_1, 0), (self.gr_fft_filter_xxx_3, 0))
self.connect((self.gr_fft_filter_xxx_3, 0), (self.gr_keep_one_in_n_0_0, 0))
self.connect((self.gr_keep_one_in_n_0_0, 0), (self.wxgui_fftsink2_0, 0))
self.connect((self.gr_keep_one_in_n_0_0, 0), (self.wxgui_waterfallsink2_0, 0))
self.connect((self.blks2_fm_deemph_0, 0), (self.gr_multiply_const_vxx_2, 0))
self.connect((self.gr_quadrature_demod_cf_0, 0), (self.gr_fft_filter_xxx_2_0, 0))
self.connect((self.gr_fft_filter_xxx_2, 0), (self.gr_keep_one_in_n_0, 0))
self.connect((self.gr_fft_filter_xxx_2, 0), (self.gr_multiply_const_vxx_0, 0))
self.connect((self.gr_fft_filter_xxx_0, 0), (self.gr_fft_filter_xxx_2, 0))
self.connect((self.gr_keep_one_in_n_1, 0), (self.gr_feedforward_agc_cc_0, 0))
self.connect((self.gr_fft_filter_xxx_2, 0), (self.gr_keep_one_in_n_1, 0))
self.connect((self.gr_fft_filter_xxx_2, 0), (self.gr_quadrature_demod_cf_0, 0))
self.connect((self.gr_fft_filter_xxx_2_0, 0), (self.blks2_fm_deemph_0, 0))
def __init__(self):
gr.top_block.__init__(self, "Magsquared")
##################################################
# Variables
##################################################
self.valdb = 0
self.variable_function_probe_0 = variable_function_probe_0 = 0
self.samp_rate = samp_rate = 125e3
self.gain = gain = 50
self.center_freq = center_freq = 925e6
s = socket.socket()
##################################################
# Blocks
##################################################
def listener():
while True:
c,addr = s.accept()
data = c.recv(1024)
if (data == 'DataRequest'):
c.send("RSS:{0}".format(self.valdb))
c.close()
self.gr_probe_avg_mag_sqrd_x_0 = gr.probe_avg_mag_sqrd_c(0, 1e-3)
def _variable_function_probe_0_probe():
s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
if len(sys.argv) == 3:
host = sys.argv[1]
port = int(sys.argv[2])
else:
host = "localhost"
port = 5006
s.bind((host,port))
s.listen(5)
serverThread = threading.Thread(target=listener)
serverThread.start()
while True:
val = self.gr_probe_avg_mag_sqrd_x_0.level()
if (val > 0):
self.valdb = 10 * math.log10(val)
print self.valdb
try: self.set_variable_function_probe_0(val)
except AttributeError, e: pass
time.sleep(1.0/(7))
_variable_function_probe_0_thread = threading.Thread(target=_variable_function_probe_0_probe)
_variable_function_probe_0_thread.daemon = True
_variable_function_probe_0_thread.start()
self.uhd_usrp_source_0 = uhd.usrp_source(
device_addr="",
stream_args=uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0.set_center_freq(center_freq, 0)
self.uhd_usrp_source_0.set_gain(gain, 0)
self.uhd_usrp_source_0.set_antenna("TX/RX", 0)
self.low_pass_filter_0 = gr.fir_filter_ccf(1, firdes.low_pass(
1, samp_rate, 5000, 1000, firdes.WIN_HAMMING, 6.76))
##################################################
# Connections
##################################################
self.connect((self.uhd_usrp_source_0, 0), (self.low_pass_filter_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.gr_probe_avg_mag_sqrd_x_0, 0))
def __init__(self, demod_class, rx_callback, options, source_block):
gr.hier_block2.__init__(self, "receive_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
options = copy.copy(
options) # make a copy so we can destructively modify
self._verbose = options.verbose
self._bitrate = options.bitrate # desired bit rate
self._rx_callback = rx_callback # this callback is fired when a packet arrives
self._demod_class = demod_class # the demodulator_class we're using
self._chbw_factor = options.chbw_factor # channel filter bandwidth factor
# Get demod_kwargs
demod_kwargs = self._demod_class.extract_kwargs_from_options(options)
#Give hooks of usrp to blocks downstream
self.source_block = source_block
#########################################
# Build Blocks
#########################################
# Build the demodulator
self.demodulator = self._demod_class(**demod_kwargs)
# Make sure the channel BW factor is between 1 and sps/2
# or the filter won't work.
if (self._chbw_factor < 1.0
or self._chbw_factor > self.samples_per_symbol() / 2):
sys.stderr.write(
"Channel bandwidth factor ({0}) must be within the range [1.0, {1}].\n"
.format(self._chbw_factor,
self.samples_per_symbol() / 2))
sys.exit(1)
# Design filter to get actual channel we want
sw_decim = 1
chan_coeffs = gr.firdes.low_pass(
1.0, # gain
sw_decim * self.samples_per_symbol(), # sampling rate
self._chbw_factor, # midpoint of trans. band
0.5, # width of trans. band
gr.firdes.WIN_HANN) # filter type
self.channel_filter = gr.fft_filter_ccc(sw_decim, chan_coeffs)
# receiver
self.packet_receiver = \
digital.demod_pkts(self.demodulator,
access_code=None,
callback=self._rx_callback,
threshold=-1)
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
self.probe = gr.probe_avg_mag_sqrd_c(thresh, alpha)
# Display some information about the setup
if self._verbose:
self._print_verbage()
# More Carrier Sensing with FFT
#self.gr_vector_sink = gr.vector_sink_c(1024)
#self.gr_stream_to_vector = gr.stream_to_vector(gr.sizeof_gr_complex*1, 1024)
#self.gr_head = gr.head(gr.sizeof_gr_complex*1024, 1024)
#self.fft = fft.fft_vcc(1024, True, (window.blackmanharris(1024)), True, 1)
# Parameters
usrp_rate = options.bitrate
self.fft_size = 1024
self.min_freq = 2.4e9 - 0.75e6
self.max_freq = 2.4e9 + 0.75e6
self.tune_delay = 0.001
self.dwell_delay = 0.01
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)
power = 0
for tap in mywindow:
power += tap * tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# 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))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
#self.freq_step = 0.75 * usrp_rate
#self.min_center_freq = self.min_freq + self.freq_step/2
#nsteps = math.ceil((self.max_freq - self.min_freq) / self.freq_step)
#self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.freq_step = 1.5e6
self.min_center_freq = self.min_freq
nsteps = 1
self.max_center_freq = self.max_freq
self.next_freq = self.min_center_freq
tune_delay = max(0,
int(round(self.tune_delay * usrp_rate /
self.fft_size))) # in fft_frames
dwell_delay = max(1,
int(
round(self.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)
######################################################
# Connect Blocks Together
######################################################
#channel-filter-->Probe_Avg_Mag_Sqrd
# -->Packet_Receiver (Demod Done Here!!)
#
# connect FFT sampler to system
#self.connect(self, self.gr_stream_to_vector, self.fft, self.gr_vector_sink)
# connect block input to channel filter
self.connect(self, self.channel_filter)
# connect the channel input filter to the carrier power detector
self.connect(self.channel_filter, self.probe)
# connect channel filter to the packet receiver
self.connect(self.channel_filter, self.packet_receiver)
# FIXME leave out the log10 until we speed it up
#self.connect(self.u, s2v, fft, c2mag, log, stats)
self.connect(self.channel_filter, s2v, fft, c2mag, stats)
def __init__(self, demod_class, rx_callback, options):
gr.hier_block2.__init__(self, "receive_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
options = copy.copy(options) # make a copy so we can destructively modify
self._verbose = options.verbose
self._bitrate = options.bitrate # desired bit rate
self._rx_callback = rx_callback # this callback is fired when a packet arrives
self._demod_class = demod_class # the demodulator_class we're using
self._chbw_factor = options.chbw_factor # channel filter bandwidth factor
# Get demod_kwargs
demod_kwargs = self._demod_class.extract_kwargs_from_options(options)
# Build the demodulator
self.demodulator = self._demod_class(**demod_kwargs)
# Make sure the channel BW factor is between 1 and sps/2
# or the filter won't work.
if(self._chbw_factor < 1.0 or self._chbw_factor > self.samples_per_symbol()/2):
sys.stderr.write("Channel bandwidth factor ({0}) must be within the range [1.0, {1}].\n".format(self._chbw_factor, self.samples_per_symbol()/2))
sys.exit(1)
# Design filter to get actual channel we want
sw_decim = 1
chan_coeffs = gr.firdes.low_pass (1.0, # gain
sw_decim * self.samples_per_symbol(), # sampling rate
self._chbw_factor, # midpoint of trans. band
0.5, # width of trans. band
gr.firdes.WIN_HANN) # filter type
self.channel_filter = gr.fft_filter_ccc(sw_decim, chan_coeffs)
# receiver
self.packet_receiver = \
digital.demod_pkts(self.demodulator,
access_code=None,
callback=self._rx_callback,
threshold=-1)
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
self.probe_lp = gr.probe_avg_mag_sqrd_c(thresh,alpha)
self.probe_hp = gr.probe_avg_mag_sqrd_c(thresh,alpha)
# Display some information about the setup
if self._verbose:
self._print_verbage()
low_pass_taps = [
-0.0401,
0.0663,
0.0468,
-0.0235,
-0.0222,
0.0572,
0.0299,
-0.1001,
-0.0294,
0.3166,
0.5302,
0.3166,
-0.0294,
-0.1001,
0.0299,
0.0572,
-0.0222,
-0.0235,
0.0468,
0.0663,
-0.0401]
high_pass_taps = [
-0.0389,
-0.0026,
0.0302,
0.0181,
-0.0357,
-0.0394,
0.0450,
0.0923,
-0.0472,
-0.3119,
0.5512,
-0.3119,
-0.0472,
0.0923,
0.0450,
-0.0394,
-0.0357,
0.0181,
0.0302,
-0.0026,
-0.0389]
#self.lp = filter.adaptive_fir_ccf("lp", 1, low_pass_taps)
#self.hp = filter.adaptive_fir_ccf("hp", 1, high_pass_taps)
self.lp = gr.fft_filter_ccc(1, low_pass_taps)
self.hp = gr.fft_filter_ccc(1, high_pass_taps)
self.power_low_pass = gr.complex_to_mag_squared()
self.power_high_pass = gr.complex_to_mag_squared()
self.power_low_pass_buf = circular_buffer_block()
self.power_high_pass_buf = circular_buffer_block()
self.connect(self, self.lp)
self.connect(self.lp, self.probe_lp)
self.connect(self, self.hp)
self.connect(self.hp, self.probe_hp)
def __init__(self, demod_class, rx_callback, options):
gr.hier_block2.__init__(
self,
"receive_path",
gr.io_signature(0, 0, 0), # Input signature
gr.io_signature(0, 0, 0)) # Output signature
options = copy.copy(
options) # make a copy so we can destructively modify
self._which = options.which # the USRP board attached
self._verbose = options.verbose
self._rx_freq = options.rx_freq # receiver's center frequency
self._rx_gain = options.rx_gain # receiver's gain
self._rx_subdev_spec = options.rx_subdev_spec # daughterboard to use
self._bitrate = options.bitrate # desired bit rate
self._decim = options.decim # Decimating rate for the USRP (prelim)
self._samples_per_symbol = options.samples_per_symbol # desired samples/symbol
self._fusb_block_size = options.fusb_block_size # usb info for USRP
self._fusb_nblocks = options.fusb_nblocks # usb info for USRP
self._rx_callback = rx_callback # this callback is fired when there's a packet available
self._demod_class = demod_class # the demodulator_class we're using
if self._rx_freq is None:
sys.stderr.write(
"-f FREQ or --freq FREQ or --rx-freq FREQ must be specified\n")
raise SystemExit
# Set up USRP source; also adjusts decim, samples_per_symbol, and bitrate
self._setup_usrp_source()
g = self.subdev.gain_range()
if options.show_rx_gain_range:
print "Rx Gain Range: minimum = %g, maximum = %g, step size = %g" \
% (g[0], g[1], g[2])
self.set_gain(options.rx_gain)
self.set_auto_tr(True) # enable Auto Transmit/Receive switching
# Set RF frequency
ok = self.set_freq(self._rx_freq)
if not ok:
print "Failed to set Rx frequency to %s" % (
eng_notation.num_to_str(self._rx_freq))
raise ValueError, eng_notation.num_to_str(self._rx_freq)
# copy the final answers back into options for use by demodulator
options.samples_per_symbol = self._samples_per_symbol
options.bitrate = self._bitrate
options.decim = self._decim
# Get demod_kwargs
demod_kwargs = self._demod_class.extract_kwargs_from_options(options)
# Design filter to get actual channel we want
sw_decim = 1
chan_coeffs = gr.firdes.low_pass(
1.0, # gain
sw_decim * self._samples_per_symbol, # sampling rate
1.0, # midpoint of trans. band
0.5, # width of trans. band
gr.firdes.WIN_HANN) # filter type
# Decimating channel filter
# complex in and out, float taps
self.chan_filt = gr.fft_filter_ccc(sw_decim, chan_coeffs)
#self.chan_filt = gr.fir_filter_ccf(sw_decim, chan_coeffs)
# receiver
self.packet_receiver = \
blks2.demod_pkts(self._demod_class(**demod_kwargs),
access_code=None,
callback=self._rx_callback,
threshold=-1)
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
if options.log_rx_power == True:
self.probe = gr.probe_avg_mag_sqrd_cf(thresh, alpha)
self.power_sink = gr.file_sink(gr.sizeof_float, "rxpower.dat")
self.connect(self.chan_filt, self.probe, self.power_sink)
else:
self.probe = gr.probe_avg_mag_sqrd_c(thresh, alpha)
self.connect(self.chan_filt, self.probe)
# Display some information about the setup
if self._verbose:
self._print_verbage()
self.connect(self.u, self.chan_filt, self.packet_receiver)
