def __init__(self, options):
gr.top_block.__init__(self, "mhp")
self.lfsr = lfsr.p25p2_lfsr(options.nac, options.sysid, options.wacn)
xor_mask = ''
for c in self.lfsr.xorsyms:
xor_mask += chr(c)
IN = blocks.file_source(gr.sizeof_char, options.input_file)
slotid = options.tdma_slotid
msgq = gr.msg_queue(2)
do_msgq = False
wireshark_host = ''
udp_port = 0
verbosity = 100
do_imbe = 1
do_output = 1
do_msgq = 0
rx_q = gr.msg_queue(1)
do_audio_output = 1
phase2_tdma = 1
FRAMER = op25_repeater.p25_frame_assembler(wireshark_host, udp_port, verbosity, do_imbe, do_output, do_msgq, rx_q, do_audio_output, phase2_tdma)
FRAMER.set_xormask(xor_mask)
S2F = blocks.short_to_float()
M = blocks.multiply_const_ff(1.0 / 32767.0)
SINK = audio.sink(8000, 'plughw:0,0')
self.connect(IN, FRAMER, S2F, M, SINK)
def __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option)
parser.add_option("-a", "--audio-input", type="string", default="")
parser.add_option("-A", "--audio-output", type="string", default="")
parser.add_option("-f", "--factor", type="eng_float", default=1)
parser.add_option("-i", "--do-interp", action="store_true", default=False, help="enable output interpolator")
parser.add_option("-s", "--sample-rate", type="int", default=48000, help="input sample rate")
parser.add_option("-S", "--stretch", type="int", default=0, help="flex amt")
parser.add_option("-y", "--symbol-rate", type="int", default=4800, help="input symbol rate")
parser.add_option("-v", "--verbose", action="store_true", default=False, help="dump demodulation data")
(options, args) = parser.parse_args()
sample_rate = options.sample_rate
symbol_rate = options.symbol_rate
IN = audio.source(sample_rate, options.audio_input)
audio_output_rate = 8000
if options.do_interp:
audio_output_rate = 48000
OUT = audio.sink(audio_output_rate, options.audio_output)
symbol_decim = 1
symbol_coeffs = gr.firdes.root_raised_cosine(1.0, # gain
sample_rate , # sampling rate
symbol_rate, # symbol rate
0.2, # width of trans. band
500) # filter type
SYMBOL_FILTER = gr.fir_filter_fff (symbol_decim, symbol_coeffs)
AMP = gr.multiply_const_ff(options.factor)
msgq = gr.msg_queue(2)
FSK4 = op25.fsk4_demod_ff(msgq, sample_rate, symbol_rate)
levels = levels = [-2.0, 0.0, 2.0, 4.0]
SLICER = repeater.fsk4_slicer_fb(levels)
framer_msgq = gr.msg_queue(2)
DECODE = repeater.p25_frame_assembler('', # udp hostname
0, # udp port no.
options.verbose, #debug
True, # do_imbe
True, # do_output
False, # do_msgq
framer_msgq)
IMBE = repeater.vocoder(False, # 0=Decode,True=Encode
options.verbose, # Verbose flag
options.stretch, # flex amount
"", # udp ip address
0, # udp port
False) # dump raw u vectors
CVT = gr.short_to_float()
if options.do_interp:
interp_taps = gr.firdes.low_pass(1.0, 48000, 4000, 4000 * 0.1, gr.firdes.WIN_HANN)
INTERP = gr.interp_fir_filter_fff(48000 // 8000, interp_taps)
AMP2 = gr.multiply_const_ff(1.0 / 32767.0)
self.connect(IN, AMP, SYMBOL_FILTER, FSK4, SLICER, DECODE, IMBE, CVT, AMP2)
if options.do_interp:
self.connect(AMP2, INTERP, OUT)
else:
self.connect(AMP2, OUT)
def __init__(self):
gr.top_block.__init__(self, "grc_cc1111_test_local_loop")
##################################################
# Variables
##################################################
self.symbole_rate = symbole_rate = 80000
self.samp_rate = samp_rate = 2e6
self.samp_per_sym = samp_per_sym = int(samp_rate / symbole_rate)
self.preamble = preamble = '0101010101010101'
self.myqueue_out = myqueue_out = gr.msg_queue(2)
self.myqueue_in = myqueue_in = gr.msg_queue(2)
self.bit_per_sym = bit_per_sym = 1
self.access_code = access_code = '11010011100100011101001110010001'
##################################################
# Blocks
##################################################
self.digital_gmsk_mod_0 = digital.gmsk_mod(
samples_per_symbol=int(samp_per_sym),
bt=0.5,
verbose=False,
log=False,
)
self.digital_correlate_access_code_bb_0_0 = digital.correlate_access_code_bb(access_code, 1)
self.digital_clock_recovery_mm_xx_0_0 = digital.clock_recovery_mm_ff(samp_per_sym*(1+0.0), 0.25*0.175*0.175, 0.5, 0.175, 0.005)
self.digital_binary_slicer_fb_0_0_0 = digital.binary_slicer_fb()
self.cc1111_cc1111_packet_encoder_0 = cc1111.cc1111_packet_mod_base(cc1111.cc1111_packet_encoder(
samples_per_symbol=samp_per_sym,
bits_per_symbol=bit_per_sym,
preamble=preamble,
access_code=access_code,
pad_for_usrp=True,
do_whitening=True,
add_crc=True
),
source_queue=myqueue_in
)
self.cc1111_cc1111_packet_decoder_0 = cc1111.cc1111_packet_decoder(myqueue_out,True, True, False, True)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_char*1, samp_rate,True)
self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_char*1)
self.analog_quadrature_demod_cf_0_0 = analog.quadrature_demod_cf(1)
##################################################
# Connections
##################################################
self.connect((self.digital_clock_recovery_mm_xx_0_0, 0), (self.digital_binary_slicer_fb_0_0_0, 0))
self.connect((self.analog_quadrature_demod_cf_0_0, 0), (self.digital_clock_recovery_mm_xx_0_0, 0))
self.connect((self.digital_binary_slicer_fb_0_0_0, 0), (self.digital_correlate_access_code_bb_0_0, 0))
self.connect((self.digital_gmsk_mod_0, 0), (self.analog_quadrature_demod_cf_0_0, 0))
self.connect((self.digital_correlate_access_code_bb_0_0, 0), (self.cc1111_cc1111_packet_decoder_0, 0))
self.connect((self.cc1111_cc1111_packet_decoder_0, 0), (self.blocks_null_sink_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.digital_gmsk_mod_0, 0))
self.connect((self.cc1111_cc1111_packet_encoder_0, 0), (self.blocks_throttle_0, 0))
def __init__(self, demodulator, options, access_code=None, callback=None, threshold=-1, use_coding=0, logging=-1):
"""
Hierarchical block for demodulating and deframing packets.
The input is the complex modulated signal at baseband.
Demodulated packets are sent to the handler.
@param demodulator: instance of demodulator class (gr_block or hier_block2)
@type demodulator: complex baseband in
@param access_code: AKA sync vector
@type access_code: string of 1's and 0's
@param callback: function of two args: ok, payload
@type callback: ok: bool; payload: string
@param threshold: detect access_code with up to threshold bits wrong (-1 -> use default)
@type threshold: int
"""
gr.hier_block2.__init__(self, "demod_pkts",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(0, 0, 0)) # Output signature
self._demodulator = demodulator
if access_code is None:
access_code = packet_utils.default_access_code
if not packet_utils.is_1_0_string(access_code):
raise ValueError, "Invalid access_code %r. Must be string of 1's and 0's" % (access_code,)
self._access_code = access_code
#just added to take coding from benchmark_rx
self._use_coding = use_coding
self._logging = logging
self._options = options
# added to simplify logging
self._threshold = options.access_code_threshold
if threshold == -1:
threshold = 4 # FIXME raise exception
self._rcvd_pktq = gr.msg_queue() # holds packets from the PHY
self._time_pktq = gr.msg_queue() # holds packet timestamps from the PHY
self._chan_pktq = gr.msg_queue() # holds packet channels from the PHY
self.correlator = digital.correlate_access_code_bb(access_code, threshold)
self.framer_sink = framer_sink_1(self._rcvd_pktq, self._time_pktq, self._chan_pktq)
self.connect(self, self._demodulator, self.correlator, self.framer_sink)
self._watcher = _queue_watcher_thread(self._rcvd_pktq, self._time_pktq, self._chan_pktq, callback, self._use_coding, self._logging, self._options)
def __init__(self):
gr.hier_block2.__init__(self,
"proto_transceiver",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(1, 1, gr.sizeof_gr_complex))
#file sinks for debugging
self.agc_out = gr.file_sink(itemsize = gr.sizeof_gr_complex,
filename = "agc.dat")
#########################
#uplink blocks
q_encoder = gr.msg_queue(100)
self.tx_encoder = rfidbts.pie_encoder(samples_per_delimiter = 8,
samples_per_tari = 16,
samples_per_pw = 8,
samples_per_trcal = 53,
samples_per_data1 = 32)
self.tx_encoder.set_encoder_queue(q_encoder)
rfidbts.cvar.rfid_mac.set_encoder_queue(q_encoder)
####################################
#downlink blocks
q_blocker = gr.msg_queue(100)
frame_size_rn16 = int((32 + 32 + 12) * 8 + int(75*0.4*1.024))
self.TX_blocker = rfidbts.receive_gate(threshold = 0.15, #bit above the noise floor
off_max = 15) #should not be in the off state for more than 13 us
self.TX_blocker.set_gate_queue(q_blocker)
rfidbts.cvar.rfid_mac.set_gate_queue(q_blocker)
self.blocker = gr.dc_blocker_cc(D = 5,
long_form = True)
self.agc = gr.agc_cc(rate = 5e-1,
reference = 0.707,
gain = 100.0,
max_gain = 1000.0)
self.search = preamble_search(frame_size_rn16)
self.half_symbols = symbol_mapper()
# self.decoder = binary_diff_decoder()
self.decoder = rfidbts.orthogonal_decode()
self.framer = rfidbts.packetizer()
#frame the rn16 and send to message queue
#####################################
#connect uplink
self.connect(self.tx_encoder, self)
#####################################
#connect downlink
self.connect(self,
self.TX_blocker,
self.blocker,
self.agc,
self.search,
self.half_symbols,
self.decoder,
self.framer)
self.connect(self.agc, self.agc_out)
def __init__(self):
gr.top_block.__init__(self, 'Message Blocks Test')
# initialize the queues
self.sink_queue = gr.msg_queue()
self.source_queue = gr.msg_queue()
# initialize the blocks
self.msg_source = gr.message_source(gr.sizeof_char, self.source_queue)
self.msg_sink = gr.message_sink(gr.sizeof_char, self.sink_queue, False)
self.connect((self.msg_source, 0), (self.msg_sink, 0))
def __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option)
parser.add_option("-i", "--input-file", type="string", default="in.dat", help="specify the input file")
parser.add_option("-g", "--gain", type="eng_float", default=1.0)
parser.add_option("-L", "--low-pass", type="eng_float", default=15e3, help="low pass cut-off", metavar="Hz")
parser.add_option("-o", "--output-file", type="string", default="out.dat", help="specify the output file")
parser.add_option("-s", "--sample-rate", type="int", default=48000, help="input sample rate")
parser.add_option("-v", "--verbose", action="store_true", default=False, help="dump demodulation data")
(options, args) = parser.parse_args()
sample_rate = options.sample_rate
sps = 10
symbol_rate = 4800
# output rate will be 48,000
ntaps = 11 * sps
channel_taps = gr.firdes.low_pass(1.0, sample_rate, options.low_pass, options.low_pass * 0.1, gr.firdes.WIN_HANN)
IN = gr.file_source(gr.sizeof_short, options.input_file)
OUT = gr.file_sink(gr.sizeof_char, options.output_file)
CVT = gr.short_to_float()
AMP = gr.multiply_const_ff(options.gain / 32767.0)
symbol_decim = 1
symbol_coeffs = gr.firdes.root_raised_cosine (1.0, # gain
sample_rate , # sampling rate
symbol_rate, # symbol rate
0.20, # width of trans. band
500) # filter type
SYMBOL_FILTER = gr.fir_filter_fff (symbol_decim, symbol_coeffs)
self.msgq = gr.msg_queue(2)
FSK4 = op25.fsk4_demod_ff(self.msgq, sample_rate, symbol_rate)
levels = [ -2.0, 0.0, 2.0, 4.0 ]
SLICER = repeater.fsk4_slicer_fb(levels)
hostname = "127.0.0.1"
port = 23456
debug = 255
do_imbe = False
do_output = True
do_msgq = False
msgqd = gr.msg_queue(2)
DECODER = repeater.p25_frame_assembler(hostname, port, debug, do_imbe, do_output, do_msgq, msgqd)
self.connect(IN, CVT, AMP, SYMBOL_FILTER, FSK4, SLICER, DECODER, OUT)
def _setup_usrpx(self, options):
self._u = uhd.usrp_sink(device_addr=options.args, stream_args=uhd.stream_args('fc32'))
self._u.set_samp_rate(options.samp_rate)
# Set the subdevice spec
if(options.spec):
self._u.set_subdev_spec(options.spec, 0)
# Set the gain on the usrp from options
if(options.gain):
self._u.set_gain(options.gain)
# Set the antenna
if(options.antenna):
self._u.set_antenna(options.antenna, 0)
self.publish(DESC_KEY, lambda: str(self._u))
self.publish(FREQ_RANGE_KEY, self._u.get_freq_range)
self.publish(GAIN_RANGE_KEY, self._u.get_gain_range)
self.publish(GAIN_KEY, self._u.get_gain)
if self._verbose:
print str(self._u)
# Direct asynchronous notifications to callback function
if options.show_async_msg:
self.async_msgq = gr.msg_queue(0)
self.async_src = uhd.amsg_source("", self.async_msgq)
self.async_rcv = gru.msgq_runner(self.async_msgq, self.async_callback)
def __init__(self, input_is_real=False, baseband_freq=0, y_per_div=10,
y_divs=8, ref_level=50,
sample_rate=1, fft_size=512,
fft_rate=default_fft_rate,
average=False, avg_alpha=None, title='',
peak_hold=False, use_persistence=False, persist_alpha=0.2):
# initialize common attributes
self.baseband_freq = baseband_freq
self.y_per_div=y_per_div
self.y_divs = y_divs
self.ref_level = ref_level
self.sample_rate = sample_rate
self.fft_size = fft_size
self.fft_rate = fft_rate
self.average = average
if avg_alpha is None:
self.avg_alpha = 2.0 / fft_rate
else:
self.avg_alpha = avg_alpha
self.use_persistence = use_persistence
self.persist_alpha = persist_alpha
self.title = title
self.peak_hold = peak_hold
self.input_is_real = input_is_real
self.msgq = gr.msg_queue(2) # queue that holds a maximum of 2 messages
def test_003_t (self):
# Annex O.3 example 2: whitening enabled
pad = (0xff,) * 8
src_data = pad + (0x55, 0x55, 0x55, 0x90, 0x4e, 0x08, 0x07, 0x4f, 0x70, 0xe5, 0x32, 0x6a, 0x62, 0x60) + pad
src_data_list = hex_list_to_binary_list(src_data)
expected_str = '\x40\x00\x56\x5d\x29\xfa\x28'
rcvd_pktq = gr.msg_queue()
src = blocks.vector_source_b(src_data_list)
correlator = digital.correlate_access_code_bb('0101010101011001000001001110', 1)
framer_sink = ieee802154g.framer_sink_mrfsk(rcvd_pktq)
vsnk = blocks.vector_sink_b()
self.tb.connect(src, correlator, framer_sink)
self.tb.connect(correlator, vsnk)
self.tb.run ()
# check data
self.assertEquals(1, rcvd_pktq.count())
result_msg = rcvd_pktq.delete_head()
fec = int(result_msg.type())
self.assertEquals(0, fec)
phr = int(result_msg.arg1())
self.assertEquals(0x0807, phr)
crc_ok = int(result_msg.arg2())
self.assertEquals(1, crc_ok)
self.assertEquals(expected_str, result_msg.to_string())
def __init__(self,options,Freq): gr.top_block.__init__(self) if options.input_file == "": self.IS_USRP2 = True else: self.IS_USRP2 = False #self.min_freq = options.start #self.max_freq = options.stop self.min_freq = Freq.value-(3*10**6) # same as that of the transmitter bandwidth ie 6MHZ approx for a given value of decimation line option any more self.max_freq = Freq.value+(3*10**6) if self.min_freq > self.max_freq: self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them print "Start and stop frequencies order swapped!" self.fft_size = options.fft_size self.ofdm_bins = options.sense_bins # build graph 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) #log = gr.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size)) # modifications for USRP2 if self.IS_USRP2: self.u = uhd.usrp_source(options.args,uhd.io_type.COMPLEX_FLOAT32,num_channels=1) # Modified Line # self.u.set_decim(options.decim) # samp_rate = self.u.adc_rate()/self.u.decim() samp_rate = 100e6/options.decim # modified sampling rate self.u.set_samp_rate(samp_rate) else: self.u = gr.file_source(gr.sizeof_gr_complex,options.input_file, True) samp_rate = 100e6 /options.decim # modified sampling rate self.freq_step =0 #0.75* samp_rate self.min_center_freq = (self.min_freq + self.max_freq)/2 global BW BW = self.max_freq - self.min_freq global size size=self.fft_size global ofdm_bins ofdm_bins = self.ofdm_bins global usr #global thrshold_inorder usr=samp_rate nsteps = 10 self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step) self.next_freq = self.min_center_freq tune_delay = max(0, int(round(options.tune_delay * samp_rate / self.fft_size))) # in fft_frames dwell_delay = max(1, int(round(options.dwell_delay * samp_rate / self.fft_size))) # in fft_frames self.msgq = gr.msg_queue(16) # thread-safe message queue 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) # control scanning and record frequency domain statistics self.connect(self.u, s2v, fft,c2mag,stats) if options.gain is None: g = self.u.get_gain_range() options.gain = float(g.start()+g.stop())/2 # if no gain was specified, use the mid-point in dB
def __init__(self, input_is_real=False, baseband_freq=0, y_per_div=10, ref_level=50,
sample_rate=1, fac_size=512,
fac_rate=default_fac_rate,
average=False, avg_alpha=None, title='', peak_hold=False):
self._item_size = gr.sizeof_gr_complex
if input_is_real:
self._item_size = gr.sizeof_float
gr.hier_block2.__init__(
self,
"Fast AutoCorrelation",
gr.io_signature(1, 1, self._item_size),
gr.io_signature(0, 0, 0),
)
# initialize common attributes
self.baseband_freq = baseband_freq
self.y_divs = 8
self.y_per_div=y_per_div
self.ref_level = ref_level
self.sample_rate = sample_rate
self.fac_size = fac_size
self.fac_rate = fac_rate
self.average = average
if (avg_alpha is None) or (avg_alpha <= 0):
self.avg_alpha = 0.20 / fac_rate # averaging needed to be slowed down for very slow rates
else:
self.avg_alpha = avg_alpha
self.title = title
self.peak_hold = peak_hold
self.input_is_real = input_is_real
self.msgq = gr.msg_queue(2) # queue that holds a maximum of 2 messages
def __init__(self, access_code='', threshold=-1, callback=None, verbose=0): """ packet_demod constructor. @param access_code AKA sync vector @param threshold detect access_code with up to threshold bits wrong (0 -> use default) @param callback a function of args: ok, payload """ #access code if not access_code: #get access code access_code = packet_utils.default_access_code if not packet_utils.is_1_0_string(access_code): raise ValueError, "Invalid access_code %r. Must be string of 1's and 0's" % (access_code,) self._access_code = access_code #threshold if threshold < 0: threshold = DEFAULT_THRESHOLD self._threshold = threshold #blocks msgq = gr.msg_queue(DEFAULT_MSGQ_LIMIT) #holds packets from the PHY correlator = digital.correlate_access_code_bb(self._access_code, self._threshold) framer_sink = logitech_27mhz_transceiver.framer_sink(msgq) #initialize hier2 gr.hier_block2.__init__( self, "packet_decoder", gr.io_signature(1, 1, gr.sizeof_char), # Input signature gr.io_signature(0, 0, 0) # Output signature ) #connect self.connect(self, correlator, framer_sink) #start thread _packet_decoder_thread(msgq, callback,verbose)
def __init__(self, port, gain, usrp_rate, lo_freq):
gr.hier_block2.__init__(self, "tx_channel_usrp",
gr.io_signature(0, 0, 0),
gr.io_signature(1, 1, gr.sizeof_gr_complex))
msg_queue = gr.msg_queue(2)
do_imbe = 1
do_float = 0
do_complex = 1
decim = MAX_COMPLEX_RATE / usrp_rate
# per-channel GR source block including these steps:
# - receive audio chunks from asterisk via UDP
# - imbe encode
# - generate phase-modulated complex output stream (table lookup method)
# - generates no power while no input received
self.chan = repeater.chan_usrp(port, do_imbe, do_complex, do_float, gain, int(decim), msg_queue)
# Local oscillator
lo = gr.sig_source_c (usrp_rate, # sample rate
gr.GR_SIN_WAVE, # waveform type
lo_freq, #frequency
1.0, # amplitude
0) # DC Offset
self.mixer = gr.multiply_cc ()
self.connect (self.chan, (self.mixer, 0))
self.connect (lo, (self.mixer, 1))
self.connect (self.mixer, self)
def __init__(self, demodulator, access_code=None, callback=None, threshold=-1):
"""
Hierarchical block for demodulating and deframing packets.
The input is the complex modulated signal at baseband.
Demodulated packets are sent to the handler.
Args:
demodulator: instance of demodulator class (gr_block or hier_block2) (complex baseband in)
access_code: AKA sync vector (string of 1's and 0's)
callback: function of two args: ok, payload (ok: bool; payload: string)
threshold: detect access_code with up to threshold bits wrong (-1 -> use default) (int)
"""
gr.hier_block2.__init__(
self, "demod_pkts", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0, 0, 0) # Input signature
) # Output signature
self._demodulator = demodulator
if access_code is None:
access_code = packet_utils.default_access_code
if not packet_utils.is_1_0_string(access_code):
raise ValueError, "Invalid access_code %r. Must be string of 1's and 0's" % (access_code,)
self._access_code = access_code
if threshold == -1:
threshold = 12 # FIXME raise exception
self._rcvd_pktq = gr.msg_queue() # holds packets from the PHY
self.correlator = digital.correlate_access_code_bb(access_code, threshold)
self.framer_sink = digital.framer_sink_1(self._rcvd_pktq)
self.connect(self, self._demodulator, self.correlator, self.framer_sink)
self._watcher = _queue_watcher_thread(self._rcvd_pktq, callback)
def main():
parser = OptionParser(option_class=eng_option)
parser.add_option("-f", "--frequency", type="eng_float", default=929.5e6,
help="set receive center frequency to Hz", metavar="Hz")
parser.add_option("-R", "--rx-subdev-spec", type="subdev",
help="select USRP Rx side A or B (default=first daughterboard found)")
parser.add_option("-c", "--calibration", type="eng_float", default=0.0,
help="set frequency offset to Hz", metavar="Hz")
parser.add_option("-g", "--gain", type="int",
help="set RF gain", metavar="dB")
parser.add_option("-F", "--from-file", default=None,
help="Read from file instead of USRP")
parser.add_option("-l", "--log", action="store_true", default=False,
help="log flowgraph to files (LOTS of data)")
parser.add_option("-v", "--verbose", action="store_true", default=False,
help="display debug output")
(options, args) = parser.parse_args()
if options.verbose:
print options
queue = gr.msg_queue()
tb = app_top_block(options, queue)
runner = pager.queue_runner(queue)
try:
tb.run()
except KeyboardInterrupt:
pass
runner.end()
def __init__(self, parent, title, vlen, decim,gsz): self._vlen = vlen self._parent = parent self._title = title print "Initing block: %s" % title self.plotQueue = Queue.Queue() self.win = matplotsink.matplotsink(parent,title, self.plotQueue,gsz) self._item_size = self._size*self._vlen #init hier block gr.hier_block2.__init__( self, 'plot_sink', gr.io_signature(1, 1, self._item_size), gr.io_signature(0, 0, 0), ) #create blocks self._msgq = gr.msg_queue(2) message_sink = gr.message_sink(self._item_size, self._msgq, False) #connect self.connect(self, message_sink) #setup thread threading.Thread.__init__(self) self.setDaemon(True) self.start()
def __init__(self, sps, channel_decim, channel_taps, options, usrp_rate, channel_rate, lo_freq):
gr.hier_block2.__init__(self, "rx_channel_fm",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(1, 1, gr.sizeof_float))
chan = gr.freq_xlating_fir_filter_ccf(int(channel_decim), channel_taps, lo_freq, usrp_rate)
symbol_decim = 1
symbol_rate = 4800
self.symbol_deviation = 600.0
fm_demod_gain = channel_rate / (2.0 * pi * self.symbol_deviation)
fm_demod = gr.quadrature_demod_cf(fm_demod_gain)
symbol_coeffs = gr.firdes_root_raised_cosine(1.0,
channel_rate,
symbol_rate,
1.0,
51)
symbol_filter = gr.fir_filter_fff(symbol_decim, symbol_coeffs)
# C4FM demodulator
autotuneq = gr.msg_queue(2)
demod_fsk4 = fsk4.demod_ff(autotuneq, channel_rate, symbol_rate)
self.connect (self, chan, fm_demod, symbol_filter, demod_fsk4, self)
def __init__(self, input_is_real=False, baseband_freq=0, y_per_div=10, sc_y_per_div=0.5, ref_level=50, sc_ref_level=20,
sample_rate=1, fft_size=512, fft_rate=15,
average=False, avg_alpha=None, title='', peak_hold=False, ofunc=None, xydfunc=None):
# initialize common attributes
self.baseband_freq = baseband_freq
self.y_divs = 8
self.y_per_div=y_per_div
self.sc_y_per_div=sc_y_per_div
self.ref_level = ref_level
self.autoscale = False
self.sc_ref_level = sc_ref_level
self.sample_rate = sample_rate
self.fft_size = fft_size
self.fft_rate = fft_rate
self.binwidth = float(sample_rate/fft_size)
self.average = average
self.ofunc = ofunc
self.xydfunc = xydfunc
self.ofunc = ofunc
if avg_alpha is None:
self.avg_alpha = 2.0 / fft_rate
else:
self.avg_alpha = avg_alpha
self.title = title
self.peak_hold = peak_hold
self.input_is_real = input_is_real
self.msgq = gr.msg_queue(2) # queue that holds a maximum of 2 messages
def __init__(self, traffic_msgq=None, key=None):
gr.hier_block2.__init__(self, "op25_decoder",
gr.io_signature(1, 1, gr.sizeof_float),
gr.io_signature(1, 1, gr.sizeof_float))
self.traffic_msgq = traffic_msgq
self.key = key
if self.traffic_msgq is None:
self.traffic_msgq = gr.msg_queue(2)
self.slicer = None
try:
levels = [ -2.0, 0.0, 2.0, 4.0 ]
self.slicer = _op25.fsk4_slicer_fb(levels)
self.p25_decoder = _op25.decoder_bf()
self.p25_decoder.set_msgq(self.traffic_msgq)
if _verbose:
print "Using new decoder_bf"
except:
try:
self.p25_decoder = _op25.decoder_ff(self.traffic_msgq) # LEGACY
if _verbose:
print "Using legacy decoder_ff"
except:
raise Exception("Could not find a decoder to use")
if (self.key is not None) and (len(self.key) > 0): # Relates to key string passed in from GRC block
self.set_key(self.key)
if self.slicer:
self.connect(self, self.slicer, self.p25_decoder)
else:
self.connect(self, self.p25_decoder)
self.connect(self.p25_decoder, self)
def xtest_004(self):
vlen = 4
tune = counter4(self, 1)
tune_delay = 1
dwell_delay = 2
msgq = gr.msg_queue()
src_data = tuple([float(x) for x in
( 1, 2, 3, 4,
9, 6, 11, 8,
5, 10, 7, 12,
13, 14, 15, 16
)])
expected_results = tuple([float(x) for x in
( 9, 10, 11, 12)])
src = gr.vector_source_f(src_data, False)
s2v = gr.stream_to_vector(gr.sizeof_float, vlen)
stats = gr.bin_statistics_f(vlen, msgq, tune, tune_delay, dwell_delay)
self.tb.connect(src, s2v, stats)
self.tb.run()
self.assertEqual(1, msgq.count())
for i in range(1):
m = parse_msg(msgq.delete_head())
#print "m =", m.center_freq, m.data
self.assertEqual(expected_results[vlen*i:vlen*i + vlen], m.data)
def __init__(self, channel_rate, auto_tune_msgq=None):
gr.hier_block2.__init__(self, "op25_fsk4",
gr.io_signature(1, 1, gr.sizeof_float),
gr.io_signature(1, 1, gr.sizeof_float))
self.symbol_rate = SYMBOL_RATE
#print "Channel rate:", channel_rate
self.channel_rate = channel_rate
self.auto_tune_msgq = auto_tune_msgq
if self.auto_tune_msgq is None:
self.auto_tune_msgq = gr.msg_queue(2)
# C4FM demodulator
#print "Symbol rate:", self.symbol_rate
try:
self.demod_fsk4 = _op25.fsk4_demod_ff(self.auto_tune_msgq, self.channel_rate, self.symbol_rate)
if _verbose:
print "Using new fsk4_demod_ff"
except:
try:
self.demod_fsk4 = fsk4.demod_ff(self.auto_tune_msgq, self.channel_rate, self.symbol_rate) # LEGACY
if _verbose:
print "Using legacy fsk4.demod_ff"
except:
raise Exception("Could not find a FSK4 demodulator to use")
self.connect(self, self.demod_fsk4, self)
def __init__(self, callback, options):
gr.top_block.__init__(self)
# hard-coded known symbol
ks1 = known_symbols_4512_1[0:options.occupied_tones]
ks2 = known_symbols_4512_2[0:options.occupied_tones]
self._rcvd_pktq = gr.msg_queue()
# accepts messages from the outside world
self.ofdm_mapper = gr.ofdm_bpsk_mapper(4, options.occupied_tones, options.fft_length, ks1, ks2)
self.ofdm_corr = gr.ofdm_correlator(options.occupied_tones, options.fft_length, 0, ks1, ks2)
self.ofdm_framer = gr.ofdm_frame_sink(self._rcvd_pktq, options.occupied_tones)
if 0: # set to 1 to put the correlator in the path to take over the signalling
self.connect((self.ofdm_mapper, 0), (self.ofdm_corr, 0))
self.connect((self.ofdm_corr, 0), (self.ofdm_framer, 0))
self.connect((self.ofdm_corr, 1), (self.ofdm_framer, 1))
self.connect((self.ofdm_mapper,0), gr.file_sink(gr.sizeof_gr_complex*options.fft_length, "ofdm_mapper.dat"))
self.connect((self.ofdm_corr,0), gr.file_sink(gr.sizeof_gr_complex*options.occupied_tones, "ofdm_corr.dat"))
self.connect((self.ofdm_corr,1), gr.file_sink(gr.sizeof_char, "ofdm_sig.dat"))
else:
self.connect((self.ofdm_mapper, 0), (self.ofdm_framer, 0))
self.connect((self.ofdm_mapper, 1), (self.ofdm_framer, 1))
self.connect((self.ofdm_mapper,0), gr.file_sink(gr.sizeof_gr_complex*options.fft_length, "ofdm_mapper.dat"))
self.connect((self.ofdm_mapper,1), gr.file_sink(gr.sizeof_char, "ofdm_sig.dat"))
self._watcher = _queue_watcher_thread(self._rcvd_pktq, callback)
def __init__(self, filename=None, capture=None, verbose=False, freq_error=-0.0021875):
gr.top_block.__init__(self)
self.verbose = verbose
self.rx_chips_min = 16
self.chip_error_threshold = 10
if None != filename:
self.source = blocks.file_source(gr.sizeof_gr_complex, filename)
else:
self.source = osmosdr.source()
#print self.source.get_gain_range().to_pp_string()
self.source.set_sample_rate(1.6e6)
self.source.set_center_freq(868.95e6, 0)
self.source.set_freq_corr(0, 0)
self.source.set_gain_mode(0, 0)
# -1.0 1.5 4.0 6.5 9.0 11.5 14.0 16.5 19.0 21.5 24.0 29.0 34.0 42.0
self.source.set_gain(14, 0)
self.source.set_if_gain(42, 0)
if None != capture:
self.sink = blocks.file_sink(gr.sizeof_gr_complex, capture)
else:
self.msgq = gr.msg_queue(4)
self.sink = wmbus_phy1(msgq=self.msgq, verbose=verbose, freq_error=freq_error);
self._watcher = _queue_watcher_thread(self.msgq, self.callback)
self.connect(self.source, self.sink)
def __init__(self, istx, args, bandwidth, freq=None,
gain=None, spec=None, antenna=None):
if(istx):
self.u = uhd.usrp_sink(device_addr=args, stream_args=uhd.stream_args('fc32'))
#self.u = uhd.usrp_sink(device_addr=args,
# io_type=uhd.io_type.COMPLEX_FLOAT32,
# num_channels=1)
# to monitor the events raised in case there was an underflow (U) or late-msg (L) problem #
self._out_pktq = gr.msg_queue()
self.u_amsg_source = uhd.amsg_source(args, self._out_pktq)
else:
self.u = uhd.usrp_source(device_addr=args, stream_args=uhd.stream_args('fc32'))
self._args = args
self._ant = antenna
self._spec = spec
self._gain = self.set_gain(gain)
self._freq = self.set_freq(freq)
self._rate = self.set_sample_rate(bandwidth)
# Set the subdevice spec
if(spec):
self.u.set_subdev_spec(spec, 0)
# Set the antenna
if(antenna):
self.u.set_antenna(antenna, 0)
time.sleep(1)
def __init__(self, *args, **kwargs):
"""
Hierarchical block for O-QPSK demodulation.
The input is the complex modulated signal at baseband.
Demodulated packets are sent to the handler.
@param callback: function of two args: ok, payload
@type callback: ok: bool; payload: string
@param threshold: detect access_code with up to threshold bits wrong (-1 -> use default)
@type threshold: int
See ieee802_15_4_demod for remaining parameters.
"""
try:
self.callback = kwargs.pop('callback')
self.threshold = kwargs.pop('threshold')
except KeyError:
pass
gr.hier_block2.__init__(self, "ieee802_15_4_demod_pkts",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input
gr.io_signature(0, 0, 0)) # Output
self._rcvd_pktq = gr.msg_queue() # holds packets from the PHY
self.ieee802_15_4_demod = ieee802_15_4.ieee802_15_4_demod(self, *args, **kwargs)
self._packet_sink = ucla.ieee802_15_4_packet_sink(self._rcvd_pktq, self.threshold)
print "GR: ieee802_15_4_pkt: Connecting demodulator and packet sink."
self.connect(self, self.ieee802_15_4_demod, self._packet_sink)
self._watcher = _queue_watcher_thread(self._rcvd_pktq, self.callback)
def __init__(self, mode, input_rate=0, context=None):
assert input_rate > 0
self.__input_rate = input_rate
gr.hier_block2.__init__(
self, 'RTTY demodulator',
gr.io_signature(1, 1, gr.sizeof_gr_complex * 1),
gr.io_signature(1, 1, gr.sizeof_float * 1))
channel_filter = self.__make_channel_filter()
self.__text = u''
self.__char_queue = gr.msg_queue(limit=100)
self.__char_sink = blocks.message_sink(gr.sizeof_char, self.__char_queue, True)
self.connect(
self,
channel_filter,
self.__make_demodulator(),
self.__char_sink)
self.connect(
channel_filter,
self.__make_audio_filter(),
blocks.rotator_cc(rotator_inc(self.__demod_rate, 2000 + self.__spacing / 2)),
blocks.complex_to_real(vlen=1),
analog.agc2_ff(
reference=dB(-10),
attack_rate=8e-1,
decay_rate=8e-1),
self)
def __init__(self, access_code=None, threshold=-1):
"""
Create a new packet deframer.
@param access_code: AKA sync vector
@type access_code: string of 1's and 0's
@param threshold: detect access_code with up to threshold bits wrong (-1 -> use default)
@type threshold: int
"""
gr.hier_block2.__init__(
self,
"demod_pkts2",
gr.io_signature(1, 1, 1),
gr.io_signature(1, 1, 1),
)
if not access_code:
access_code = packet_utils.default_access_code
if not packet_utils.is_1_0_string(access_code):
raise ValueError, "Invalid access_code %r. Must be string of 1's and 0's" % (access_code,)
if threshold == -1:
threshold = 12 # FIXME raise exception
msgq = gr.msg_queue(4) # holds packets from the PHY
self.correlator = gr_digital.correlate_access_code_bb(access_code, threshold)
self.framer_sink = gr.framer_sink_1(msgq)
self.connect(self, self.correlator, self.framer_sink)
self._queue_to_blob = _queue_to_blob(msgq)
self.connect(self._queue_to_blob, self)
def test_002_t (self):
# CRC-16 test from section 5.2.1.9 in 802.15.4-2011
pad = (0xff,) * 8
src_data = pad + (0x55, 0x55, 0x90, 0x4e, 0x10, 0x05, 0x40, 0x00, 0x56, 0x27, 0x9e) + pad
src_data_list = hex_list_to_binary_list(src_data)
expected_str = '\x40\x00\x56\x27\x9e'
rcvd_pktq = gr.msg_queue()
src = blocks.vector_source_b(src_data_list)
correlator = digital.correlate_access_code_bb('0101010101011001000001001110', 1)
framer_sink = ieee802154g.framer_sink_mrfsk(rcvd_pktq)
vsnk = blocks.vector_sink_b()
self.tb.connect(src, correlator, framer_sink)
self.tb.connect(correlator, vsnk)
self.tb.run ()
# check data
self.assertEquals(1, rcvd_pktq.count())
result_msg = rcvd_pktq.delete_head()
fec = int(result_msg.type())
self.assertEquals(0, fec)
phr = int(result_msg.arg1())
self.assertEquals(0x1005, phr)
crc_ok = int(result_msg.arg2())
self.assertEquals(1, crc_ok)
self.assertEquals(expected_str, result_msg.to_string())
def publish_rx_spectrum(self,fftlen):
## RX Spectrum
fftlen = 256
my_window = window.hamming(fftlen) #.blackmanharris(fftlen)
rxs_sampler = vector_sampler(gr.sizeof_gr_complex,fftlen)
rxs_trigger = gr.vector_source_b(concatenate([[1],[0]*199]),True)
rxs_window = blocks.multiply_const_vcc(my_window)
rxs_spectrum = gr.fft_vcc(fftlen,True,[],True)
rxs_mag = gr.complex_to_mag(fftlen)
rxs_avg = gr.single_pole_iir_filter_ff(0.01,fftlen)
rxs_logdb = gr.nlog10_ff(20.0,fftlen,-20*log10(fftlen))
rxs_decimate_rate = gr.keep_one_in_n(gr.sizeof_float*fftlen,1)
msgq = gr.msg_queue(5)
rxs_msg_sink = gr.message_sink(gr.sizeof_float*fftlen,msgq,True)
self.connect(rxs_trigger,(rxs_sampler,1))
t = self.u if self.filter is None else self.filter
self.connect(t,rxs_sampler,rxs_window,
rxs_spectrum,rxs_mag,rxs_avg,rxs_logdb, rxs_decimate_rate,
rxs_msg_sink)
self.servants.append(corba_data_buffer_servant("spectrum",fftlen,msgq))
print "RXS trigger unique id", rxs_trigger.unique_id()
print "Publishing RX baseband under id: spectrum"
def __init__(self,
parent,
title='Eye Diagram',
sample_rate=1,
size=default_scopesink_size,
frame_decim=default_frame_decim,
samples_per_symbol=10,
num_plots=100,
sym_decim=20,
v_scale=default_v_scale,
t_scale=None,
num_inputs=1,
**kwargs):
if t_scale == 0:
t_scale = None
if v_scale == 0:
v_scale = default_v_scale
gr.hier_block2.__init__(
self, "datascope_sink_f",
gr.io_signature(num_inputs, num_inputs, gr.sizeof_float),
gr.io_signature(0, 0, 0))
msgq = gr.msg_queue(2) # message queue that holds at most 2 messages
self.st = gr.message_sink(gr.sizeof_float, msgq, dont_block=1)
self.connect((self, 0), self.st)
self.win = datascope_window(
datascope_win_info(
msgq,
sample_rate,
frame_decim,
v_scale,
t_scale,
#None, # scopesink (not used)
title=title),
parent,
samples_per_symbol=samples_per_symbol,
num_plots=num_plots,
sym_decim=sym_decim,
size=size)
def __init__(self, options, context):
gr.top_block.__init__(self)
pubsub.__init__(self)
self._options = options
self._queue = gr.msg_queue()
self._rate = int(options.rate)
self._resample = None
self._setup_source(options)
self._rx_path = air_modes.rx_path(self._rate, options.threshold,
self._queue, options.pmf,
options.dcblock)
#now subscribe to set various options via pubsub
self.subscribe("freq", self.set_freq)
self.subscribe("gain", self.set_gain)
self.subscribe("rate", self.set_rate)
self.subscribe("rate", self._rx_path.set_rate)
self.subscribe("threshold", self._rx_path.set_threshold)
self.subscribe("pmf", self._rx_path.set_pmf)
self.publish("freq", self.get_freq)
self.publish("gain", self.get_gain)
self.publish("rate", self.get_rate)
self.publish("threshold", self._rx_path.get_threshold)
self.publish("pmf", self._rx_path.get_pmf)
if self._resample is not None:
self.connect(self._u, self._resample, self._rx_path)
else:
self.connect(self._u, self._rx_path)
#Publish messages when they come back off the queue
server_addr = ["inproc://modes-radio-pub"]
if options.tcp is not None:
server_addr += ["tcp://*:%i" % options.tcp]
self._sender = air_modes.zmq_pubsub_iface(context,
subaddr=None,
pubaddr=server_addr)
self._async_sender = gru.msgq_runner(self._queue, self.send)
def __init__(self,
parent,
title='',
sample_rate=1,
size=(495, 450),
frame_rate=5,
const_size=1024,
mod='DBPSK'):
#init
gr.hier_block2.__init__(
self,
"const_sink",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0),
)
self.sd = blks2.stream_to_vector_decimator(
item_size=gr.sizeof_gr_complex,
sample_rate=sample_rate,
vec_rate=frame_rate,
vec_len=const_size,
)
self.agc = gr.agc2_cc(0.6e-1, 1e-3, 1, 1, 100)
self.gain = gr.multiply_const_cc(utils.gain[mod])
msgq = gr.msg_queue(2)
sink = gr.message_sink(gr.sizeof_gr_complex * const_size, msgq, True)
#connect
self.connect(self, self.agc, self.gain, self.sd, sink)
#controller
def setter(p, k, x):
p[k] = x
self.controller = pubsub()
#initial update
common.input_watcher(msgq, self.controller, MSG_KEY)
#create window
self.win = const_window(parent=parent,
controller=self.controller,
size=size,
title=title,
msg_key=MSG_KEY)
common.register_access_methods(self, self.win)
def __init__(self, rate): #TODO pass in chanlist
gr.hier_block2.__init__(self,
"smartnet_ctrl_rx",
gr.io_signature(1,1,gr.sizeof_gr_complex),
gr.io_signature(0,0,0))
self.set_assign_callback(None)
self._queue = gr.msg_queue()
self._async_sender = gru.msgq_runner(self._queue, self.msg_handler)
self._syms_per_sec = 3600.
self._sps = rate / self._syms_per_sec
self._demod = scanner.fsk_demod(self._sps, 0.1)
self._sof = digital.correlate_access_code_tag_bb("10101100",
0,
"smartnet_preamble")
self._deinterleave = scanner.deinterleave()
self._crc = scanner.crc(self._queue)
self.connect(self, self._demod, self._sof, self._deinterleave, self._crc)
def __init__(self, rate): #TODO pass in chanlist
gr.hier_block2.__init__(self,
"edacs_ctrl_rx",
gr.io_signature(1,1,gr.sizeof_gr_complex),
gr.io_signature(0,0,0))
self.set_assign_callback(None)
self._queue = gr.msg_queue()
self._async_sender = gru.msgq_runner(self._queue, self.msg_handler)
self._syms_per_sec = 9600.
self._sps = rate / self._syms_per_sec
self._demod = scanner.fsk_demod(self._sps, 0.575)
self._invert = scanner.invert()
self._sof = digital.correlate_access_code_tag_bb("010101010101010101010111000100100101010101010101",
0,
"edacs_preamble")
self._rx = scanner.edacs_pkt_rx(self._queue)
self.connect(self, self._demod, self._invert, self._sof, self._rx)
def __init__(self, packet_source=None, payload_length=0):
if not payload_length: #get payload length
payload_length = DEFAULT_PAYLOAD_LEN
if payload_length%self._item_size_in != 0: #verify that packet length is a multiple of the stream size
raise ValueError, 'The payload length: "%d" is not a mutiple of the stream size: "%d".'%(payload_length, self._item_size_in)
#initialize hier2
gr.hier_block2.__init__(
self,
"ofdm_mod",
gr.io_signature(1, 1, self._item_size_in), # Input signature
gr.io_signature(1, 1, packet_source._hb.output_signature().sizeof_stream_item(0)) # Output signature
)
#create blocks
msgq = gr.msg_queue(DEFAULT_MSGQ_LIMIT)
msg_sink = blocks.message_sink(self._item_size_in, msgq, False) #False -> blocking
#connect
self.connect(self, msg_sink)
self.connect(packet_source, self)
#start thread
_packet_encoder_thread(msgq, payload_length, packet_source.send_pkt)
def __init__(self, input_q, output_q, endpoint, **kwds):
global my_input_q, my_output_q, my_recv_q, my_port
host, port = endpoint.split(':')
if my_port is not None:
raise AssertionError('this server is already active on port %s' %
my_port)
my_input_q = input_q
my_output_q = output_q
my_port = int(port)
my_recv_q = gr.msg_queue(10)
SEND_BYTES = 1024
NTHREADS = 10 # TODO: make #threads a function of #plots ?
self.server = create_server(application,
host=host,
port=my_port,
send_bytes=SEND_BYTES,
expose_tracebacks=True,
threads=NTHREADS)
def __init__(self, vlen, decim, callback): self._vlen = vlen self._callback = callback self._item_size = self._size*self._vlen #init hier block gr.hier_block2.__init__( self, 'variable_sink', gr.io_signature(1, 1, self._item_size), gr.io_signature(0, 0, 0), ) #create blocks self._decimator = gr.keep_one_in_n(self._item_size, decim) self._msgq = gr.msg_queue(2) message_sink = gr.message_sink(self._item_size, self._msgq, False) #connect self.connect(self, self._decimator, message_sink) #setup thread threading.Thread.__init__(self) self.setDaemon(True) self.start()
def __init__(self,
input_is_real=False,
baseband_freq=0,
y_per_div=10,
ref_level=50,
sample_rate=1,
fac_size=512,
fac_rate=default_fac_rate,
average=False,
avg_alpha=None,
title='',
peak_hold=False):
self._item_size = gr.sizeof_gr_complex
if input_is_real:
self._item_size = gr.sizeof_float
gr.hier_block2.__init__(
self,
"Fast AutoCorrelation",
gr.io_signature(1, 1, self._item_size),
gr.io_signature(0, 0, 0),
)
# initialize common attributes
self.baseband_freq = baseband_freq
self.y_divs = 8
self.y_per_div = y_per_div
self.ref_level = ref_level
self.sample_rate = sample_rate
self.fac_size = fac_size
self.fac_rate = fac_rate
self.average = average
if (avg_alpha is None) or (avg_alpha <= 0):
self.avg_alpha = 0.20 / fac_rate # averaging needed to be slowed down for very slow rates
else:
self.avg_alpha = avg_alpha
self.title = title
self.peak_hold = peak_hold
self.input_is_real = input_is_real
self.msgq = gr.msg_queue(2) # queue that holds a maximum of 2 messages
def __init__(self,
type='BER',
win_size=default_win_size,
bits_per_symbol=2):
"""
Error rate constructor.
@param type a string 'BER' or 'SER'
@param win_size the number of samples to calculate over
@param bits_per_symbol the number of information bits per symbol (BER only)
"""
#init
gr.hier_block2.__init__(
self,
'error_rate',
gr.io_signature(2, 2, gr.sizeof_char),
gr.io_signature(1, 1, gr.sizeof_float),
)
assert type in ('BER', 'SER')
self._max_samples = win_size
self._bits_per_symbol = bits_per_symbol
#setup message queue
msg_source = gr.message_source(gr.sizeof_float, 1)
self._msgq_source = msg_source.msgq()
msgq_sink = gr.msg_queue(2)
msg_sink = gr.message_sink(gr.sizeof_char, msgq_sink,
False) #False -> blocking
inter = gr.interleave(gr.sizeof_char)
#start thread
self._num_errs = 0
self._err_index = 0
self._num_samps = 0
self._err_array = numpy.zeros(self._max_samples, numpy.int8)
if type == 'BER':
input_watcher(msgq_sink, self._handler_ber)
elif type == 'SER':
input_watcher(msgq_sink, self._handler_ser)
#connect
self.connect(msg_source, self)
self.connect((self, 0), (inter, 0))
self.connect((self, 1), (inter, 1))
self.connect(inter, msg_sink)
def __init__(self, vlen=1): """! Queue sink base contructor. @param vlen the vector length """ self._vlen = vlen #initialize hier2 gr.hier_block2.__init__( self, "queue_sink", gr.io_signature(1, 1, self._item_size*self._vlen), # Input signature gr.io_signature(0, 0, 0) # Output signature ) #create message sink self._msgq = gr.msg_queue(4) message_sink = blocks_swig0.message_sink(self._item_size*self._vlen, self._msgq, False) #False -> blocking #connect self.connect(self, message_sink) self.arr = None self.idx = 0
def __init__(self,
if_rate = None,
symbol_rate = _def_symbol_rate):
"""
Hierarchical block for P25 demodulation base class
@param if_rate: sample rate of complex input channel
@type if_rate: int
"""
self.if_rate = if_rate
self.symbol_rate = symbol_rate
self.bb_sink = None
self.baseband_amp = blocks.multiply_const_ff(_def_bb_gain)
coeffs = op25_c4fm_mod.c4fm_taps(sample_rate=self.if_rate, span=9, generator=op25_c4fm_mod.transfer_function_rx).generate()
self.symbol_filter = filter.fir_filter_fff(1, coeffs)
autotuneq = gr.msg_queue(2)
self.fsk4_demod = op25.fsk4_demod_ff(autotuneq, self.if_rate, self.symbol_rate)
levels = [ -2.0, 0.0, 2.0, 4.0 ]
self.slicer = op25_repeater.fsk4_slicer_fb(levels)
def __init__(self, mode, input_rate=0, context=None):
assert input_rate > 0
self.__input_rate = input_rate
gr.hier_block2.__init__(
self, type(self).__name__,
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(1, 1, gr.sizeof_float))
channel_filter = self.__make_channel_filter()
self.__char_queue = gr.msg_queue(limit=100)
self.__char_sink = blocks.message_sink(gr.sizeof_char, self.__char_queue, True)
# The output of the channel filter is oversampled so we don't need to
# interpolate for the audio monitor. So we'll downsample before going into
# the demodulator.
samp_per_sym = 8
downsample = self.__demod_rate / samp_per_sym / self.__symbol_rate
assert downsample % 1 == 0
downsample = int(downsample)
self.connect(
self,
channel_filter,
blocks.keep_one_in_n(gr.sizeof_gr_complex, downsample),
psk31_coherent_demodulator_cc(samp_per_sym=samp_per_sym),
psk31_constellation_decoder_cb(
varicode_decode=True,
differential_decode=True),
self.__char_sink)
self.connect(
channel_filter,
blocks.rotator_cc(rotator_inc(self.__demod_rate, self.__audio_frequency)),
blocks.complex_to_real(vlen=1),
analog.agc2_ff(
reference=dB(-10),
attack_rate=8e-1,
decay_rate=8e-1),
self)
def __init__(self):
gr.top_block.__init__(self, "CC430 Transmitter")
self.sent_pkts = 0
# 5555 5555 2c6e fd00 0071 da0b e2
self.packet = chr(0x55) * 4 # preamble
self.packet += chr(0x2c) + chr(0x6e) # sync
self.packet += chr(0xfc) # length
self.packet += chr(0x00) + chr(0x00) + chr(0x00) # payload
self.packet += chr(0x71) + chr(0xda) + chr(0x0b) + chr(
0xe2) # CRC (currently incorrect)
# Variables
self.samp_rate = samp_rate = 125e3
self.f_center = f_center = 868e6
self.bandwidth = bandwidth = 200e3
self.gain = gain = 5
self.msgq = msgq = gr.msg_queue()
# Blocks
self.uhd_sink = uhd.usrp_sink(
device_addr="",
stream_args=uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_sink.set_samp_rate(samp_rate)
self.uhd_sink.set_center_freq(f_center, 0)
self.uhd_sink.set_gain(gain, 0)
self.uhd_sink.set_bandwidth(bandwidth, 0)
self.msg_src = gr.message_source(1, msgq)
self.msk = level.msk_mod_bc(samples_per_symbol=2, bt=0.3)
# Connections
self.connect(self.msg_src, self.msk, self.uhd_sink)
def main():
parser = OptionParser(option_class=eng_option)
parser.add_option("-f",
"--factor",
type="eng_float",
default=1.0,
help="multiply factor")
parser.add_option("-i",
"--input-file",
type="string",
default="in.dat",
help="specify the input file")
parser.add_option("-r",
"--repeat",
action="store_true",
default=False,
help="repeat input in a loop")
parser.add_option("-v",
"--reverse",
action="store_true",
default=False,
help="reverse polarity")
parser.add_option("-s", "--sample-rate", type="int", default=48000)
parser.add_option("-O",
"--audio-output",
type="string",
default="",
help="pcm input device name. E.g., hw:0,0 or /dev/dsp")
(options, args) = parser.parse_args()
queue = gr.msg_queue()
tb = app_top_block(options, queue)
try:
tb.start()
while 1:
if not queue.empty_p():
sys.stderr.write("main: q.delete_head()\n")
msg = queue.delete_head()
except KeyboardInterrupt:
tb.stop()
def __init__(self, fft_len, sample_rate, tune_freq, average, rate, width,
height):
gr.hier_block2.__init__(self, "ascii plot",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
self.fft_len = fft_len
self.sample_rate = sample_rate
self.average = average
self.tune_freq = tune_freq
self.rate = rate
self.width = width
self.height = height
self.msgq = gr.msg_queue(2)
#######BLOCKS#####
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len)
self.one_in_n = blocks.keep_one_in_n(
gr.sizeof_gr_complex * self.fft_len,
max(1, int(self.sample_rate / self.fft_len / self.rate)))
mywindow = window.blackmanharris(self.fft_len)
self.fft = fft.fft_vcc(self.fft_len, True, (), True)
self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len)
self.avg = grfilter.single_pole_iir_filter_ff(1.0, self.fft_len)
self.log = blocks.nlog10_ff(
10,
self.fft_len,
-10 * math.log10(self.fft_len) # Adjust for number of bins
- 10 * math.log10(self.sample_rate)) # Adjust for sample rate
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len,
self.msgq, True)
#####CONNECTIONS####
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2,
self.avg, self.log, self.sink)
self._main = main_thread(self.msgq, self.fft_len, self.sample_rate,
self.tune_freq, self.width, self.height)
def configure_metadata(self, config):
meta_mod = config['module']
if meta_mod.endswith('.py'):
meta_mod = meta_mod[:-3]
try:
self.metadata = importlib.import_module(meta_mod)
except:
self.metadata = None
sys.stderr.write(
"Error: unable to import metadata module: %s\n%s\n" %
(config['module'], sys.exc_info()[1]))
idx = 0
for stream in config['streams']:
if 'stream_name' in stream and stream['stream_name'] != "":
stream_name = stream['stream_name']
if stream_name in self.meta_streams:
sys.stderr.write(
"Ignoring duplicate metadata stream #%d [%s]\n" %
(idx, stream_name))
break
try:
meta_q = gr.msg_queue(10)
meta_s = self.metadata.meta_server(meta_q,
stream,
debug=self.verbosity)
self.meta_streams[stream_name] = (meta_s, meta_q)
sys.stderr.write(
"Configuring metadata stream #%d [%s]: %s\n" %
(idx, stream_name, stream['icecastServerAddress'] +
"/" + stream['icecastMountpoint']))
except:
sys.stderr.write(
"Error configuring metadata stream #%d; %s\n" %
(idx, sys.exc_info()[1]))
#sys.exc_clear()
else:
sys.stderr.write("Ignoring unnamed metadata stream #%d\n" %
idx)
idx += 1
def __init__(self):
gr.top_block.__init__(self, "Testbb")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
self.gr_head_0 = gr.head(gr.sizeof_char * 1, 1040)
self.gr_rds_data_decoder_0_0 = rds.data_decoder(gr.msg_queue())
self.gr_rds_data_encoder_1 = rds.data_encoder(
"/media/dimitris/mywork/gr/dimitris/rds/trunk/src/utils/rds_data.xml"
)
##################################################
# Connections
##################################################
self.connect((self.gr_rds_data_encoder_1, 0), (self.gr_head_0, 0))
self.connect((self.gr_head_0, 0), (self.gr_rds_data_decoder_0_0, 0))
def __build_graph(self, source, capture_rate):
# tell the scope the source rate
self.spectrum.set_sample_rate(capture_rate)
# channel filter
self.channel_offset = 0.0
channel_decim = capture_rate // self.channel_rate
channel_rate = capture_rate // channel_decim
trans_width = 12.5e3 / 2;
trans_centre = trans_width + (trans_width / 2)
coeffs = gr.firdes.low_pass(1.0, capture_rate, trans_centre, trans_width, gr.firdes.WIN_HANN)
self.channel_filter = gr.freq_xlating_fir_filter_ccf(channel_decim, coeffs, -9500.0, capture_rate)
self.set_channel_offset(0.0, 0, self.spectrum.win._units)
# power squelch
squelch_db = -60
self.squelch = gr.pwr_squelch_cc(squelch_db, 1e-3, 0, True)
self.set_squelch_threshold(squelch_db)
# FM demodulator
fm_demod_gain = channel_rate / (2.0 * pi * self.symbol_deviation)
fm_demod = gr.quadrature_demod_cf(fm_demod_gain)
# symbol filter
symbol_decim = 1
#symbol_coeffs = gr.firdes.root_raised_cosine(1.0, channel_rate, self.symbol_rate, 0.2, 500)
# boxcar coefficients for "integrate and dump" filter
samples_per_symbol = channel_rate // self.symbol_rate
symbol_coeffs = (1.0/samples_per_symbol,)*samples_per_symbol
symbol_filter = gr.fir_filter_fff(symbol_decim, symbol_coeffs)
# C4FM demodulator
autotuneq = gr.msg_queue(2)
self.demod_watcher = demod_watcher(autotuneq, self.adjust_channel_offset)
demod_fsk4 = op25.fsk4_demod_ff(autotuneq, channel_rate, self.symbol_rate)
reverser = gr.multiply_const_ff(-1.0)
# for now no audio output
sink = gr.null_sink(gr.sizeof_float)
# connect it all up
self.__connect([[source, self.channel_filter, self.squelch, fm_demod, symbol_filter, demod_fsk4, reverser, self.slicer, self.p25_decoder, sink],
[source, self.spectrum],
[symbol_filter, self.signal_scope],
[demod_fsk4, self.symbol_scope]])
def __init__(self, access_code='', threshold=-1, callback=None):
"""
packet_demod constructor.
Args:
access_code: AKA sync vector
threshold: detect access_code with up to threshold bits wrong (0 -> use default)
callback: a function of args: ok, payload
"""
#access code
if not access_code: #get access code
access_code = packet_utils.default_access_code
if not packet_utils.is_1_0_string(access_code):
raise ValueError, "Invalid access_code %r. Must be string of 1's and 0's" % (
access_code, )
self._access_code = access_code
#threshold
if threshold < 0: threshold = DEFAULT_THRESHOLD
self._threshold = threshold
#blocks
msgq = gr.msg_queue(DEFAULT_MSGQ_LIMIT) #holds packets from the PHY
correlator = digital.correlate_access_code_bb(self._access_code,
self._threshold)
framer_sink = digital.framer_sink_1(msgq)
#initialize hier2
gr.hier_block2.__init__(
self,
"packet_decoder",
gr.io_signature(1, 1, gr.sizeof_char), # Input signature
gr.io_signature(1, 1, 1) # Output signature
)
#connect
self.connect(self, correlator, framer_sink)
self.pktout = packet_decoder_out()
self.connect(self.pktout, self)
#start thread
_packet_decoder_thread(msgq, self.pktout.callback)
def __init__(self, reactor, send, block, audio_rate):
self._send = send
self._queue = gr.msg_queue(limit=100)
self.__running = [True]
self._block = block
self._block.add_audio_queue(self._queue, audio_rate)
# We don't actually benefit specifically from using a SignalType in this context but it avoids reinventing vocabulary.
signal_type = SignalType(
kind='STEREO'
if self._block.get_audio_queue_channels() == 2 else 'MONO',
sample_rate=audio_rate)
send(
serialize({
# Not used to discriminate, but it seems worth applying the convention in general.
u'type': u'audio_stream_metadata',
u'signal_type': signal_type,
}))
reactor.callInThread(_AudioStream_read_loop, reactor, self._queue,
self.__deliver, self.__running)
def __init__(self, packet_len=500):
gr.hier_block2.__init__(self, "payload_source",
gr.io_signature(0, 0, 0),
gr.io_signature(1, 1, gr.sizeof_char * 1))
self.packet_len = packet_len
# initialize the message queues
self.source_queue = gr.msg_queue()
##################################################
# Blocks
self.msg_source = blocks.message_source(gr.sizeof_char * 1,
self.source_queue)
self.stream_to_tagged_stream_txpath = blocks.stream_to_tagged_stream(
gr.sizeof_char, 1, packet_len, "packet_len")
##################################################
# Connections
#Data source
self.connect(self.msg_source, self.stream_to_tagged_stream_txpath,
self)
def __init__(self, traffic_msgq=None, key=None):
gr.hier_block2.__init__(self, "op25_decoder",
gr.io_signature(1, 1, gr.sizeof_float),
gr.io_signature(1, 1, gr.sizeof_float))
self.traffic_msgq = traffic_msgq
self.key = key
if self.traffic_msgq is None:
self.traffic_msgq = gr.msg_queue(2)
self.slicer = None
try:
levels = [-2.0, 0.0, 2.0, 4.0]
self.slicer = _op25.fsk4_slicer_fb(levels)
self.p25_decoder = _op25.decoder_bf()
self.p25_decoder.set_msgq(self.traffic_msgq)
if _verbose:
print "Using new decoder_bf"
except:
try:
self.p25_decoder = _op25.decoder_ff(
self.traffic_msgq) # LEGACY
if _verbose:
print "Using legacy decoder_ff"
except:
raise Exception("Could not find a decoder to use")
if (self.key is not None) and (
len(self.key) >
0): # Relates to key string passed in from GRC block
self.set_key(self.key)
if self.slicer:
self.connect(self, self.slicer, self.p25_decoder)
else:
self.connect(self, self.p25_decoder)
self.connect(self.p25_decoder, self)
def __init__(self, mode, input_rate=0, context=None):
assert input_rate > 0
gr.hier_block2.__init__(
self,
'RTTY demodulator',
gr.io_signature(1, 1, gr.sizeof_gr_complex * 1),
gr.io_signature(1, 1, gr.sizeof_float * 1),
)
self.__text = u''
baud = _DEFAULT_BAUD # TODO param
self.baud = baud
demod_rate = 6000 # TODO optimize this value
self.samp_rate = demod_rate # TODO rename
self.__channel_filter = MultistageChannelFilter(
input_rate=input_rate,
output_rate=demod_rate,
cutoff_freq=self.__filter_high,
transition_width=self.__transition) # TODO optimize filter band
self.__sharp_filter = grfilter.fir_filter_ccc(
1,
firdes.complex_band_pass(1.0, demod_rate, self.__filter_low,
self.__filter_high, self.__transition,
firdes.WIN_HAMMING))
self.fsk_demod = RTTYFSKDemodulator(input_rate=demod_rate, baud=baud)
self.__real = blocks.complex_to_real(vlen=1)
self.__char_queue = gr.msg_queue(limit=100)
self.char_sink = blocks.message_sink(gr.sizeof_char, self.__char_queue,
True)
self.connect(
self, self.__channel_filter, self.__sharp_filter, self.fsk_demod,
rtty.rtty_decode_ff(rate=demod_rate, baud=baud, polarity=False),
self.char_sink)
self.connect(self.__sharp_filter, self.__real, self)
def __init__(self,
input_is_real=False,
baseband_freq=0,
sample_rate=1,
fft_size=512,
fft_rate=default_fft_rate,
average=False,
avg_alpha=None,
title=''):
# initialize common attributes
self.baseband_freq = baseband_freq
self.sample_rate = sample_rate
self.fft_size = fft_size
self.fft_rate = fft_rate
self.average = average
if avg_alpha is None:
self.avg_alpha = 2.0 / fft_rate
else:
self.avg_alpha = avg_alpha
self.title = title
self.input_is_real = input_is_real
self.msgq = gr.msg_queue(2) # queue up to 2 messages
def test_002(self):
code = tuple(string_to_1_0_list(default_access_code))
access_code = to_1_0_string(code)
header = tuple(2*[0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]) # len=2
pad = (0,) * 100
src_data = code + header + (0,1,0,0,1,0,0,0) + (0,1,0,0,1,0,0,1) + pad
expected_data = 'HI'
rcvd_pktq = gr.msg_queue()
src = blocks.vector_source_b(src_data)
correlator = digital.correlate_access_code_bb(access_code, 0)
framer_sink = digital.framer_sink_1(rcvd_pktq)
vsnk = blocks.vector_sink_b()
self.tb.connect(src, correlator, framer_sink)
self.tb.connect(correlator, vsnk)
self.tb.run()
result_data = rcvd_pktq.delete_head()
result_data = result_data.to_string()
self.assertEqual(expected_data, result_data)
def __init__(self, port, gain, soundcard_rate):
gr.hier_block2.__init__(self, "tx_channel_soundcard",
gr.io_signature(0, 0, 0),
gr.io_signature(1, 1, gr.sizeof_float))
msg_queue = gr.msg_queue(2)
do_imbe = 1
do_float = 1
do_complex = 0
if soundcard_rate == 96000:
decim = 1
else:
decim = 2 # for 48000
# per-channel GR source block including these steps:
# - receive audio chunks from asterisk via UDP
# - imbe encode
# - generate float output stream (table lookup method)
# - generates zero power while no input received
self.chan = repeater.chan_usrp(port, do_imbe, do_complex, do_float,
1.0, decim, msg_queue)
self.amp = gr.multiply_const_ff(gain)
self.connect(self.chan, self.amp, self)
def __init__(self, *args, **kwargs):
"""
Hierarchical block for O-QPSK demodulation.
The input is the complex modulated signal at baseband.
Demodulated packets are sent to the handler.
@param callback: function of two args: ok, payload
@type callback: ok: bool; payload: string
@param threshold: detect access_code with up to threshold bits wrong (-1 -> use default)
@type threshold: int
See ieee802_15_4_demod for remaining parameters.
"""
try:
self.callback = kwargs.pop('callback')
self.threshold = kwargs.pop('threshold')
self.chan_num = kwargs.pop('channel')
except KeyError:
pass
gr.hier_block2.__init__(
self,
"ieee802_15_4_demod_pkts",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input
gr.io_signature(0, 0, 0)) # Output
self._rcvd_pktq = gr.msg_queue() # holds packets from the PHY
self.ieee802_15_4_demod = ieee802_15_4.ieee802_15_4_demod(
self, *args, **kwargs)
self._packet_sink = ucla.ieee802_15_4_packet_sink(
self._rcvd_pktq, self.threshold)
self.connect(self, self.ieee802_15_4_demod, self._packet_sink)
self._watcher = _queue_watcher_thread(self._rcvd_pktq, self.callback,
self.chan_num)
def __init__(self, fg, access_code=None, callback=None, threshold=-1, *args, **kwargs):
"""
Hierarchical block for binary FSK demodulation.
The input is the complex modulated signal at baseband.
Demodulated packets are sent to the handler.
@param fg: flow graph
@type fg: flow graph
@param access_code: 64-bit sync code
@type access_code: string of length 8
@param callback: function of two args: ok, payload
@type callback: ok: bool; payload: string
@param threshold: detect access_code with up to threshold bits wrong (-1 -> use default)
@type threshold: int
See cc1k_demod for remaining parameters.
"""
if access_code is None:
#this is 0x999999995a5aa5a5
access_code = chr(153) + chr(153) + chr(153) + chr(153) + chr(90) + chr(90) + chr(165) + chr(165)
if not isinstance(access_code, str) or len(access_code) != 8:
raise ValueError, "Invalid access_code '%r' len '%r'" % (access_code, len(access_code),)
self._access_code = access_code
self._rcvd_pktq = gr.msg_queue() # holds packets from the PHY
self.cc1k_demod = cc1k.cc1k_demod(fg, *args, **kwargs)
self._packet_sink = ucla.sos_packet_sink(map(ord, access_code), self._rcvd_pktq, threshold)
fg.connect(self.cc1k_demod, self._packet_sink)
#filesink = gr.file_sink (gr.sizeof_char, "/tmp/rx.log")
#fg.connect(self.cc1k_demod,filesink)
gr.hier_block.__init__(self, fg, self.cc1k_demod, None)
self._watcher = _queue_watcher_thread(self._rcvd_pktq, callback)
def __init__(self,
parent,
title='',
sample_rate=1,
size=default_scopesink_size,
frame_decim=default_frame_decim,
v_scale=default_v_scale,
t_scale=None,
num_inputs=1,
**kwargs):
gr.hier_block2.__init__(
self, "scope_sink_f",
gr.io_signature(num_inputs, num_inputs, gr.sizeof_float),
gr.io_signature(0, 0, 0))
msgq = gr.msg_queue(2) # message queue that holds at most 2 messages
self.guts = wxgui.oscope_sink_f(sample_rate, msgq)
for i in range(num_inputs):
self.connect((self, i), (self.guts, i))
self.win = scope_window(
win_info(msgq, sample_rate, frame_decim, v_scale, t_scale,
self.guts, title), parent)
