def test_bytes_to_syms_001(self):
src_data = (0x01, 0x80, 0x03)
expected_result = (-1, -1, -1, -1, -1, -1, -1, +1, +1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, +1, +1)
src = gr.vector_source_b(src_data)
op = gr.bytes_to_syms()
dst = gr.vector_sink_f()
self.tb.connect(src, op)
self.tb.connect(op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
def test_bytes_to_syms_001 (self):
src_data = (0x01, 0x80, 0x03)
expected_result = (-1, -1, -1, -1, -1, -1, -1, +1,
+1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, +1, +1)
src = gr.vector_source_b (src_data)
op = gr.bytes_to_syms ()
dst = gr.vector_sink_f ()
self.tb.connect (src, op)
self.tb.connect (op, dst)
self.tb.run ()
result_data = dst.data ()
self.assertEqual (expected_result, result_data)
def __init__(self):
gr.top_block.__init__(self)
self.src = gr.message_source(gr.sizeof_char, msgq_limit)
src = self.src
b_to_syms = gr.bytes_to_syms()
self.mult = gr.multiply_const_ff(MULTIPLIER)
add = gr.add_const_ff(CENTER_FREQ)
repeater = gr.repeat(gr.sizeof_float,REPEAT_TIME)
fsk_f = gr.vco_f(AUDIO_RATE, 2*pi,0.5)
speaker = audio.sink(AUDIO_RATE, "plughw:0,0");
self.connect(src,b_to_syms,self.mult,add,repeater,fsk_f,speaker)
def __init__(self, fg, spb = 8, bt = 0.3):
"""
Hierarchical block for cc1k FSK modulation.
The input is a byte stream (unsigned char) and the
output is the complex modulated signal at baseband.
@param fg: flow graph
@type fg: flow graph
@param spb: samples per baud >= 2
@type spb: integer
@param bt: Gaussian filter bandwidth * symbol time
@type bt: float
"""
if not isinstance(spb, int) or spb < 2:
raise TypeError, "sbp must be an integer >= 2"
self.spb = spb
#sensitivity = (pi / 2) / spb # phase change per bit = pi / 2
sensitivity = 3.5*pi / spb
# Turn it into NRZ data.
self.nrz = gr.bytes_to_syms()
# Manchester Encode the whole thing and upsample by 8
self.manchester = ucla.manchester_ff()
# FM modulation
self.fmmod = gr.frequency_modulator_fc(sensitivity)
# Connect
fg.connect(self.nrz, self.manchester)
fg.connect(self.manchester, self.fmmod)
#filesink1 = gr.file_sink(gr.sizeof_float, 'nrz.dat')
#fg.connect(self.nrz, filesink1)
#filesink = gr.file_sink(gr.sizeof_float, 'manchester.dat')
#fg.connect(self.manchester, filesink)
# Initialize base class
gr.hier_block.__init__(self, fg, self.nrz, self.fmmod)
def __init__(self, fg, spb=8, bt=0.3):
"""
Hierarchical block for cc1k FSK modulation.
The input is a byte stream (unsigned char) and the
output is the complex modulated signal at baseband.
@param fg: flow graph
@type fg: flow graph
@param spb: samples per baud >= 2
@type spb: integer
@param bt: Gaussian filter bandwidth * symbol time
@type bt: float
"""
if not isinstance(spb, int) or spb < 2:
raise TypeError, "sbp must be an integer >= 2"
self.spb = spb
#sensitivity = (pi / 2) / spb # phase change per bit = pi / 2
sensitivity = 3.5 * pi / spb
# Turn it into NRZ data.
self.nrz = gr.bytes_to_syms()
# Manchester Encode the whole thing and upsample by 8
self.manchester = ucla.manchester_ff()
# FM modulation
self.fmmod = gr.frequency_modulator_fc(sensitivity)
# Connect
fg.connect(self.nrz, self.manchester)
fg.connect(self.manchester, self.fmmod)
#filesink1 = gr.file_sink(gr.sizeof_float, 'nrz.dat')
#fg.connect(self.nrz, filesink1)
#filesink = gr.file_sink(gr.sizeof_float, 'manchester.dat')
#fg.connect(self.manchester, filesink)
# Initialize base class
gr.hier_block.__init__(self, fg, self.nrz, self.fmmod)
def __init__(self):
gr.top_block.__init__(self)
audio_rate =48000 # audio rate changed
self.src = gr.message_source(gr.sizeof_char, msgq_limit)
src = self.src
b_to_syms = gr.bytes_to_syms()
mult = gr.multiply_const_ff(1000)
add = gr.add_const_ff(CentreFreq)
repeater = gr.repeat(gr.sizeof_float,RepeatTime)
fsk_f = gr.vco_f(audio_rate, 2*pi,0.5) # Sensitivity is rad/sec/volt ( e.g 2*pi*f/sec = 1Khz) and here f = volts (input amplitude of VCO)
attenuator = gr.multiply_const_ff(0.05) # multiply
speaker = audio.sink(audio_rate, "plughw:0,0");
dst = gr.wavfile_sink("tx-signal.wav",1, audio_rate, 16)
self.connect(src,b_to_syms,mult,add,repeater,fsk_f,attenuator,speaker)
self.connect(fsk_f,dst)
def __init__(self, fg,
samples_per_symbol=_def_samples_per_symbol,
bt=_def_bt,
verbose=_def_verbose,
log=_def_log):
"""
Hierarchical block for Gaussian Minimum Shift Key (GMSK)
modulation.
The input is a byte stream (unsigned char) and the
output is the complex modulated signal at baseband.
@param fg: flow graph
@type fg: flow graph
@param samples_per_symbol: samples per baud >= 2
@type samples_per_symbol: integer
@param bt: Gaussian filter bandwidth * symbol time
@type bt: float
@param verbose: Print information about modulator?
@type verbose: bool
@param debug: Print modualtion data to files?
@type debug: bool
"""
self._fg = fg
self._samples_per_symbol = samples_per_symbol
self._bt = bt
if not isinstance(samples_per_symbol, int) or samples_per_symbol < 2:
raise TypeError, ("samples_per_symbol must be an integer >= 2, is %r" % (samples_per_symbol,))
ntaps = 4 * samples_per_symbol # up to 3 bits in filter at once
sensitivity = (pi / 2) / samples_per_symbol # phase change per bit = pi / 2
# Turn it into NRZ data.
self.nrz = gr.bytes_to_syms()
# Form Gaussian filter
# Generate Gaussian response (Needs to be convolved with window below).
self.gaussian_taps = gr.firdes.gaussian(
1, # gain
samples_per_symbol, # symbol_rate
bt, # bandwidth * symbol time
ntaps # number of taps
)
self.sqwave = (1,) * samples_per_symbol # rectangular window
self.taps = numpy.convolve(numpy.array(self.gaussian_taps),numpy.array(self.sqwave))
self.gaussian_filter = gr.interp_fir_filter_fff(samples_per_symbol, self.taps)
# FM modulation
self.fmmod = gr.frequency_modulator_fc(sensitivity)
if verbose:
self._print_verbage()
if log:
self._setup_logging()
# Connect & Initialize base class
self._fg.connect(self.nrz, self.gaussian_filter, self.fmmod)
gr.hier_block.__init__(self, self._fg, self.nrz, self.fmmod)
def __init__(self,
samples_per_symbol=_def_samples_per_symbol,
sensitivity=_def_sensitivity,
bt=_def_bt,
verbose=_def_verbose,
log=_def_log):
"""
Hierarchical block for Gaussian Frequency Shift Key (GFSK)
modulation.
The input is a byte stream (unsigned char) and the
output is the complex modulated signal at baseband.
@param samples_per_symbol: samples per baud >= 2
@type samples_per_symbol: integer
@param bt: Gaussian filter bandwidth * symbol time
@type bt: float
@param verbose: Print information about modulator?
@type verbose: bool
@param debug: Print modualtion data to files?
@type debug: bool
"""
gr.hier_block2.__init__(self, "gfsk_mod",
gr.io_signature(1, 1, gr.sizeof_char), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
samples_per_symbol = int(samples_per_symbol)
self._samples_per_symbol = samples_per_symbol
self._bt = bt
self._differential = False
if not isinstance(samples_per_symbol, int) or samples_per_symbol < 2:
raise TypeError, ("samples_per_symbol must be an integer >= 2, is %r" % (samples_per_symbol,))
ntaps = 4 * samples_per_symbol # up to 3 bits in filter at once
#sensitivity = (pi / 2) / samples_per_symbol # phase change per bit = pi / 2
# Turn it into NRZ data.
self.nrz = gr.bytes_to_syms()
# Form Gaussian filter
# Generate Gaussian response (Needs to be convolved with window below).
self.gaussian_taps = gr.firdes.gaussian(
1.0, # gain
samples_per_symbol, # symbol_rate
bt, # bandwidth * symbol time
ntaps # number of taps
)
self.sqwave = (1,) * samples_per_symbol # rectangular window
self.taps = numpy.convolve(numpy.array(self.gaussian_taps),numpy.array(self.sqwave))
self.gaussian_filter = gr.interp_fir_filter_fff(samples_per_symbol, self.taps)
# FM modulation
self.fmmod = gr.frequency_modulator_fc(sensitivity)
# small amount of output attenuation to prevent clipping USRP sink
self.amp = gr.multiply_const_cc(0.999)
if verbose:
self._print_verbage()
if log:
self._setup_logging()
# Connect & Initialize base class
self.connect(self, self.nrz, self.gaussian_filter, self.fmmod, self.amp, self)
def __init__(self, options, parent):
'''
See below for what options should hold
'''
gr.hier_block2.__init__(self, "transmit_path",
gr.io_signature(0, 0, 0), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
options = copy.copy(options) # make a copy so we can destructively modify
self._bitrate = options.bitrate # desired bit rate
#self._inter = options.inter # Decimating rate for the USRP (prelim)
self._samples_per_symbol = options.samples_per_symbol # desired samples/symbol
self._down_sample_rate = options.down_sample_rate
self._verbose = options.verbose
self._tx_amplitude = options.tx_amplitude # digital amplitude sent to USRP
self._use_whitener_offset = options.use_whitener_offset # increment start of whitener XOR data
self._access_code = packet_utils.conv_packed_binary_string_to_1_0_string(default_ola_spade_code)
self._subchannel = options.subchannel
self._msgq_limit = 4
self.parent = parent
# Turn it into NRZ data.
self.nrz = gr.bytes_to_syms()
self.sqwave = (1,) * self._samples_per_symbol # rectangular window
self.gaussian_filter = gr.interp_fir_filter_fff(self._samples_per_symbol, self.sqwave)
#Sensitivity will be seletected by set_sensitivity function in main loop
self.sensitivity_a = (2 *pi * self._subchannel) / self._samples_per_symbol # phase change per bit = pi / 2 (for BFSK)
self.sensitivity_b = (2 *pi * (self._subchannel)) / self._samples_per_symbol # phase change per bit = pi / 2 (for BFSK)
self._pad_for_usrp = True
self._use_whitener_offset = False
self._whitener_offset = 0
# TODO
# BUG : Improve or Implement Stream Selector!!!! (Check the new GNU Radio blocks!!!)
# =============================================================================
# The first flowgraph for Digital Only Modulation
# =============================================================================
self._pkt_input = gr.message_source(gr.sizeof_char, self._msgq_limit) # accepts messages from the outside world
self.fmmod = gtlib.bfsk_modulator_fc(self.sensitivity_a,self.sensitivity_b) # BFSK modulation
self.amp = gr.multiply_const_cc(1) # (Note that on the RFX cards this is a nop.)
self.amp_2 = gr.multiply_const_cc(1) # (Sub channel correction)
if self._subchannel >= 1 and self._subchannel <= 4:
self.amp_2.set_k(pow(1.2,(float(self._subchannel)-1)))
#self.timetag_inserter = gtlib.usrp_timetag_insert()
if self._verbose:
self._print_verbage() # Display some information about the setup
# =============================================================================
# Flowgraph connection
# =============================================================================
self.connect(self._pkt_input, self.nrz, self.gaussian_filter,self.fmmod,self.amp, self.amp_2, self)
self.set_tx_amplitude(self._tx_amplitude)
