def BuildFFT(self,scope=True):
fft0w = filter.window.blackmanharris(2048)
fft0 = fft.fft_vcc(2048, True, fft0w, True)
fft1w = filter.window.blackmanharris(2048)
fft1 = fft.fft_vcc(2048, True, fft1w, True)
self.connect(self.rx0,blocks.stream_to_vector(gr.sizeof_gr_complex, 2048),fft0)
self.connect(self.rx1,blocks.stream_to_vector(gr.sizeof_gr_complex, 2048),fft1)
v2s = blocks.vector_to_stream(gr.sizeof_float,20)
fp2 = findphase_c(2048)
self.connect(fft0,(fp2,0))
self.connect(fft1,(fp2,1))
self.connect(fp2,v2s)
if scope:
self.ffth = qtgui.histogram_sink_f(100,360,-179,180,"FFT Phase Histogram")
#self.ffth.enable_autoscale(False)
self.ffth.enable_accumulate(True)
self.ffth.enable_grid(True)
#self.histo.enable_menu(True)
self.connect(v2s,self.ffth)
self.ffthqt = sip.wrapinstance(self.ffth.pyqwidget(), QtGui.QWidget)
self.ffthqt.show()
def __init__(self):
gr.top_block.__init__(self)
self.sample_rate = 5000000
self.ampl = 0.1
self.freq = 144000000
self.uhd = uhd.usrp_source(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd.set_samp_rate(self.sample_rate)
self.uhd.set_center_freq(self.freq, 0)
self.uhd.set_gain(0, 0)
self.uhd.set_antenna("RX2", 0)
self.fft_vxx_0 = fft.fft_vcc(1024, True, (window.blackmanharris(1024)), True, 1)
self.throttle = blocks.throttle(gr.sizeof_gr_complex*1, self.sample_rate,True)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, self.sample_rate,True)
self.stream = blocks.stream_to_vector_decimator(
item_size=gr.sizeof_gr_complex,
sample_rate=self.sample_rate,
vec_rate=30,
vec_len=1024,
)
self.probe = blocks.probe_signal_vf(1024)
self.fft = fft.fft_vcc(1024, True, (window.blackmanharris(1024)), True, 1)
src0 = analog.sig_source_c(self.sample_rate, analog.GR_SIN_WAVE, self.freq, self.ampl)
dst = audio.sink(self.sample_rate, "")
self.sqrt = blocks.complex_to_mag_squared(1024)
def fft_out():
while 1:
val = self.probe.level()
print max(val)
freq = (val.index(max(val)) * (self.sample_rate/1024.0)) + (self.freq - (self.sample_rate/2.0))
print freq
time.sleep(1)
fft_thread = threading.Thread(target=fft_out)
fft_thread.daemon = True
fft_thread.start()
self.connect((self.uhd,0),(self.throttle, 0))
self.connect((self.throttle,0),(self.stream,0))
self.connect((self.stream, 0),(self.fft, 0))
self.connect((self.fft, 0),(self.sqrt, 0))
self.connect((self.sqrt, 0),(self.probe, 0))
def __init__(self, N=12, M=256, indices=[], mapping=0, modulation=16, cp_ratio=0.25):
gr.hier_block2.__init__(self,
"scfdma_receiver_cb",
gr.io_signature(1, 1, gr.sizeof_gr_complex*1),
gr.io_signature(len(indices), len(indices), gr.sizeof_char*1),
)
##################################################
# Parameters
##################################################
self.indices = indices
self.modulation = modulation
self.cp_ratio = cp_ratio
self.M = M
self.N = N
self.mapping = mapping
##################################################
# Variables
##################################################
self.demappers = demappers = list()
self.idft_blocks = idft_blocks = list()
self.estimation_blocks = estimation_blocks = list()
##################################################
# Blocks
##################################################
# self.ofdm_scfdma_subcarrier_demapper_vcvc_0 = ofdm.scfdma_subcarrier_demapper_vcvc(N, M, start_index, mapping)
# self.ofdm_fbmc_symbol_estimation_vcb_0 = ofdm.fbmc_symbol_estimation_vcb(N, modulation)
# self.fft_vxx_0_0 = fft.fft_vcc(N, False, (), True, 1)
self.fft_vxx_0 = fft.fft_vcc(M, True, (), True, 1)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, M)
self.blocks_keep_m_in_n_0 = blocks.keep_m_in_n(gr.sizeof_gr_complex, M, int(M*(1+cp_ratio)), int(cp_ratio*M))
# create demappers, idft and estimation blocks
for i in range(len(indices)):
self.demappers.append(ofdm.scfdma_subcarrier_demapper_vcvc(N, M, indices[i], mapping))
self.idft_blocks.append(fft.fft_vcc(N, False, (), True, 1))
self.estimation_blocks.append(ofdm.fbmc_symbol_estimation_vcb(N, modulation))
##################################################
# Connections
##################################################
self.connect((self, 0), (self.blocks_keep_m_in_n_0, 0))
self.connect((self.blocks_keep_m_in_n_0, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
# connect the rest
for i in range(len(indices)):
self.connect((self.fft_vxx_0, 0), (self.demappers[i],0))
self.connect((self.demappers[i],0), (self.idft_blocks[i],0))
self.connect((self.idft_blocks[i],0), (self.estimation_blocks[i],0))
self.connect((self.estimation_blocks[i],0), (self, i))
def test_004_connect(self):
"""
Advanced test:
- Allocator -> IFFT -> Frequency offset -> FFT -> Serializer
- FFT does shift (moves DC to middle)
- Make sure input == output
- Frequency offset is -2 carriers
"""
fft_len = 8
n_syms = 1
carr_offset = -2
freq_offset = 1.0 / fft_len * carr_offset # Normalized frequency
occupied_carriers = ((-2, -1, 1, 2),)
pilot_carriers = ((-3,), (3,))
pilot_symbols = ((1j,), (-1j,))
tx_data = (1, 2, 3, 4)
tag_name = "len"
tag = gr.tag_t()
tag.offset = 0
tag.key = pmt.string_to_symbol(tag_name)
tag.value = pmt.from_long(len(tx_data))
offsettag = gr.tag_t()
offsettag.offset = 0
offsettag.key = pmt.string_to_symbol("ofdm_sync_carr_offset")
offsettag.value = pmt.from_long(carr_offset)
src = blocks.vector_source_c(tx_data, False, 1, (tag, offsettag))
alloc = digital.ofdm_carrier_allocator_cvc(
fft_len, occupied_carriers, pilot_carriers, pilot_symbols, (), tag_name
)
tx_ifft = fft.fft_vcc(fft_len, False, (1.0 / fft_len,) * fft_len, True)
oscillator = analog.sig_source_c(1.0, analog.GR_COS_WAVE, freq_offset, 1.0 / fft_len)
mixer = blocks.multiply_cc()
rx_fft = fft.fft_vcc(fft_len, True, (), True)
sink2 = blocks.vector_sink_c(fft_len)
self.tb.connect(rx_fft, sink2)
serializer = digital.ofdm_serializer_vcc(alloc, "", 0, "ofdm_sync_carr_offset", True)
sink = blocks.vector_sink_c()
self.tb.connect(
src,
alloc,
tx_ifft,
blocks.vector_to_stream(gr.sizeof_gr_complex, fft_len),
(mixer, 0),
blocks.stream_to_vector(gr.sizeof_gr_complex, fft_len),
rx_fft,
serializer,
sink,
)
self.tb.connect(oscillator, (mixer, 1))
self.tb.run()
self.assertComplexTuplesAlmostEqual(sink.data()[-len(occupied_carriers[0]) :], tx_data, places=4)
def __init__(self): 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)) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 2.4e6 ################################################## # Blocks ################################################## self.howto_spectrum_sensing_cf_0 = howto.spectrum_sensing_cf(samp_rate,2048,16,0.001,0.0001,1.9528,True,True,0,200000.0,False,3,4,1,6) self.gr_null_sink_0 = gr.null_sink(gr.sizeof_float*1) self.fft_vxx_0 = fft.fft_vcc(2048, True, (window.blackmanharris(1024)), False, 1) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, 2048) self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, 1000, 1, 0) ################################################## # Connections ################################################## self.connect((self.fft_vxx_0, 0), (self.howto_spectrum_sensing_cf_0, 0)) self.connect((self.howto_spectrum_sensing_cf_0, 0), (self.gr_null_sink_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0)) self.connect((self.analog_sig_source_x_0, 0), (self.blocks_stream_to_vector_0, 0))
def test_reverse_window_shift(self):
src_data = tuple([x / self.fft_size for x in primes_transformed])
expected_result = (
(-74.8629 - 63.2502j), (-3.5446 - 2.0365j), (2.9231 + 1.6827j),
(-2.7852 - 0.8613j), (2.4763 + 2.7881j), (-2.7457 - 3.2602j),
(4.7748 + 2.4145j), (-2.8807 - 4.5313j), (5.9949 + 4.1976j),
(-6.1095 - 6.0681j), (5.2248 + 5.7743j), (-6.0436 - 6.3773j),
(9.7184 + 9.2482j), (-8.2791 - 8.6507j), (6.3273 + 6.1560j),
(-12.2841 - 12.4692j), (10.5816 + 10.0241j), (-13.0312 - 11.9451j),
(12.2983 + 13.3644j), (-13.0372 - 14.0795j), (14.4682 + 13.3079j),
(-16.7673 - 16.7287j), (14.3946 + 11.5916j), (-16.8368 - 21.3156j),
(20.4528 + 16.8499j), (-18.4075 - 18.2446j), (17.7507 + 19.2109j),
(-21.5207 - 20.7159j), (22.2183 + 19.8012j), (-22.2144 - 20.0343j),
(17.0359 + 17.6910j), (-91.8955 - 103.1093j))
window = fft.window.hamming(ntaps=self.fft_size)
src = blocks.vector_source_c(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
op = fft.fft_vcc(self.fft_size, False, window, True)
v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, self.fft_size)
dst = blocks.vector_sink_c()
self.tb.connect(src, s2v, op, v2s, dst)
self.tb.run()
result_data = dst.data()
self.assert_fft_ok2(expected_result, result_data)
def __init__(self, dBm, pfa, pfd, useless_bw, plot_histogram):
gr.top_block.__init__(self)
# Constants
samp_rate = 2.4e6
samples_per_band = 16
tcme = 1.9528
output_pfa = True
debug_stats = False
self.histogram = plot_histogram
primary_user_location = 5
mu = 0
fft_size = 4096
nframes_to_check = 1
nframes_to_average = 1
downconverter = 1
src_data = self.generateRandomSignalSource(dBm, fft_size, mu, nframes_to_check*nframes_to_average)
# Blocks
src = gr.vector_source_c(src_data)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1)
self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,self.histogram,nframes_to_check,nframes_to_average,downconverter)
self.sink = gr.vector_sink_f()
# Connections
self.connect(src, s2v, fftb, self.ss, self.sink)
def __init__(self, fft_len, rate, sample_rate):
gr.hier_block2.__init__(self, "psd_logger",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
self.fft_len = fft_len
self.rate = rate
self.sample_rate = sample_rate
self.msgq = gr.msg_queue(2)
self.log_file = open(
'/tmp/psd_log' + '-' + time.strftime("%y%m%d") + '-' +
time.strftime("%H%M%S"), 'w')
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, mywindow)
power = 0
for tap in mywindow:
power += tap * tap
self.c2mag = blocks.complex_to_mag(self.fft_len)
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len,
self.msgq, True)
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag,
self.sink)
self._watcher = _queue_watcher(self.msgq, self.log_file)
def __init__(self, N=400):
gr.top_block.__init__(self, "Compress Fft")
##################################################
# Parameters
##################################################
self.N = N
##################################################
# Blocks
##################################################
self.rfsniffer_stream_to_vector_overlap_0 = rfsniffer.stream_to_vector_overlap(gr.sizeof_gr_complex, N, N/2)
self.fft_vxx_0 = fft.fft_vcc(N, True, (window.hanning(N)), True, 1)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_gr_complex*1, N)
self.blocks_file_source_0 = blocks.file_source(gr.sizeof_gr_complex*1, "/tmp/capture.iq", False)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_gr_complex*1, "/tmp/compress_fft.iq", False)
self.blocks_file_sink_0.set_unbuffered(False)
##################################################
# Connections
##################################################
self.connect((self.blocks_file_source_0, 0), (self.rfsniffer_stream_to_vector_overlap_0, 0))
self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.rfsniffer_stream_to_vector_overlap_0, 0), (self.fft_vxx_0, 0))
def __init__(self, dBm, pfa, pfd, nTrials):
gr.top_block.__init__(self)
# Constants
samp_rate = 2.4e6
fft_size = 4096
samples_per_band = 16
tcme = 1.9528
output_pfa = True
debug_stats = False
histogram = False
primary_user_location = 0
useless_bw = 200000.0
src_data = [0+0j]*fft_size*nTrials
voltage = self.powerToAmplitude(dBm);
# Blocks
src = gr.vector_source_c(src_data)
noise = gr.noise_source_c(gr.GR_GAUSSIAN, voltage, 42)
add = gr.add_vcc()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1)
ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram)
self.sink = gr.vector_sink_f()
# Connections
self.connect(src, add, s2v, fftb, ss, self.sink)
self.connect(noise, (add, 1))
def __init__(self, fft_size=2048, decim=100): gr.hier_block2.__init__( self, "RA:FFT", gr.io_signature(1, 1, gr.sizeof_gr_complex*1), gr.io_signature(1, 1, gr.sizeof_float*fft_size), ) ################################################## # Parameters ################################################## self.fft_size = fft_size self.decim = decim ################################################## # Blocks ################################################## self.single_pole_iir_filter_xx_0 = filter.single_pole_iir_filter_ff(1.0/decim, fft_size) self.fft_vxx_0 = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), True, 1) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, fft_size) self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff(([1.0/fft_size]*fft_size)) self.blocks_keep_one_in_n_0 = blocks.keep_one_in_n(gr.sizeof_float*fft_size, decim) self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(fft_size) ################################################## # Connections ################################################## self.connect((self.blocks_multiply_const_vxx_0, 0), (self.single_pole_iir_filter_xx_0, 0)) self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_multiply_const_vxx_0, 0)) self.connect((self.single_pole_iir_filter_xx_0, 0), (self.blocks_keep_one_in_n_0, 0)) self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0)) self.connect((self, 0), (self.blocks_stream_to_vector_0, 0)) self.connect((self.blocks_keep_one_in_n_0, 0), (self, 0))
def __init__(self):
gr.hier_block2.__init__(self, "ofdm_tx",
gr.io_signature(1, 1, gr.sizeof_char),
gr.io_signature(1, 1, gr.sizeof_gr_complex))
self.sequencr = aux.insert_sequence_numbers_bb()
self.encoder = aux.encoder_reed_solomon_bb()
self.framer = blocks.stream_to_tagged_stream(
gr.sizeof_char, 1, config.get_bytes_per_frame(),
LEN_TAG_KEY) #divide the incoming data streams in frames
self.connect(self, self.sequencr, self.encoder, self.framer)
#We can do some byte scrambling if needed (variable modulus modulation )
self.unpacker_data_stream = blocks.repack_bits_bb( #modulation of the data (split the bytes, and modulate the split bytes
8, config.get_bits_per_symbol(), LEN_TAG_KEY)
self.modulator_data_stream = digital.chunks_to_symbols_bc(
config.get_constellation().points())
self.connect(self.framer, self.unpacker_data_stream,
self.modulator_data_stream)
self.allocator = digital.ofdm_carrier_allocator_cvc(
config.get_fft_length(),
occupied_carriers=config.get_data_tones(),
pilot_carriers=config.get_pilot_tones(),
pilot_symbols=config.get_pilot_symbols(),
sync_words=config.get_preambles(),
len_tag_key=LEN_TAG_KEY)
self.connect(self.modulator_data_stream, self.allocator)
self.fft_block = fft.fft_vcc(config.get_fft_length(), False, (), True)
self.connect(self.allocator, self.fft_block)
self.prefixer = digital.ofdm_cyclic_prefixer(
config.get_fft_length(),
config.get_cp_length() + config.get_fft_length(), 0, LEN_TAG_KEY)
self.burst_handler = aux.add_zeros_cc(
14, 104) #digital.burst_shaper_cc([],1040,1040,False, LEN_TAG_KEY)
self.connect(self.fft_block, self.prefixer, self.burst_handler)
self.connect(self.burst_handler, self)
def __init__(self, window_size):
gr.hier_block2.__init__(self, "FFT_IFFT", gr.io_signature(1,1,gr.sizeof_float), gr.io_signature(1,1,gr.sizeof_float))
vector_to_stream = blocks.vector_to_stream(gr.sizeof_gr_complex, window_size)
stream_to_vector = blocks.stream_to_vector(gr.sizeof_float, window_size)
divide = blocks.divide_cc(1)
complex_to_float = blocks.complex_to_float(1)
fft_forward = fft.fft_vfc(window_size, True, (fft.window.blackmanharris(window_size)), 1)
fft_backward = fft.fft_vcc(window_size, False, (fft.window.blackmanharris(window_size)), False, 1)
constant = analog.sig_source_c(0, analog.GR_CONST_WAVE, 0, 0, window_size)
#print("1. Connect self to stream_to_vector")
self.connect((self, 0), (stream_to_vector, 0))
#print("2. Connect stream_to_vector to fft_forward")
self.connect((stream_to_vector, 0), (fft_forward, 0))
#print("3. Connect fft_forward to fft_backward")
self.connect((fft_forward, 0), (fft_backward, 0))
#print("4. Connect fft_backward to vector_to_stream")
self.connect((fft_backward, 0), (vector_to_stream, 0))
#print("5. Connect vector_to_stream to port 0 of divide")
self.connect((vector_to_stream, 0), (divide, 0))
#print("6. Connect constant to port 1 of divide")
self.connect(constant, (divide, 1))
#print("7. Connect divide to complex_to_float")
self.connect((divide, 0), (complex_to_float, 0))
#print("8. Connect complex_to_float to self")
self.connect((complex_to_float, 0), (self, 0))
def __init__(self, n_chans, n_filterbanks=1, taps=None, outchans=None,
atten=100, bw=1.0, tb=0.2, ripple=0.1):
if n_filterbanks > n_chans:
n_filterbanks = n_chans
if outchans is None:
outchans = range(n_chans)
gr.hier_block2.__init__(
self, "pfb_channelizer_hier_ccf",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(len(outchans), len(outchans), gr.sizeof_gr_complex))
if taps is None:
taps = optfir.low_pass(1, n_chans, bw, bw+tb, ripple, atten)
taps = list(taps)
extra_taps = int(math.ceil(1.0*len(taps)/n_chans)*n_chans - len(taps))
taps = taps + [0] * extra_taps
# Make taps for each channel
chantaps = [list(reversed(taps[i: len(taps): n_chans])) for i in range(0, n_chans)]
# Convert the input stream into a stream of vectors.
self.s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, n_chans)
# Create a mapping to separate out each filterbank (a group of channels to be processed together)
# And a list of sets of taps for each filterbank.
low_cpp = int(n_chans/n_filterbanks)
extra = n_chans - low_cpp*n_filterbanks
cpps = [low_cpp+1]*extra + [low_cpp]*(n_filterbanks-extra)
splitter_mapping = []
filterbanktaps = []
total = 0
for cpp in cpps:
splitter_mapping.append([(0, i) for i in range(total, total+cpp)])
filterbanktaps.append(chantaps[total: total+cpp])
total += cpp
assert(total == n_chans)
# Split the stream of vectors in n_filterbanks streams of vectors.
self.splitter = blocks.vector_map(gr.sizeof_gr_complex, [n_chans], splitter_mapping)
# Create the filterbanks
self.fbs = [filter.filterbank_vcvcf(taps) for taps in filterbanktaps]
# Combine the streams of vectors back into a single stream of vectors.
combiner_mapping = [[]]
for i, cpp in enumerate(cpps):
for j in range(cpp):
combiner_mapping[0].append((i, j))
self.combiner = blocks.vector_map(gr.sizeof_gr_complex, cpps, combiner_mapping)
# Add the final FFT to the channelizer.
self.fft = fft.fft_vcc(n_chans, forward=True, window=[1.0]*n_chans)
# Select the desired channels
if outchans != range(n_chans):
selector_mapping = [[(0, i) for i in outchans]]
self.selector = blocks.vector_map(gr.sizeof_gr_complex, [n_chans], selector_mapping)
# Convert stream of vectors to a normal stream.
self.v2ss = blocks.vector_to_streams(gr.sizeof_gr_complex, len(outchans))
self.connect(self, self.s2v, self.splitter)
for i in range(0, n_filterbanks):
self.connect((self.splitter, i), self.fbs[i], (self.combiner, i))
self.connect(self.combiner, self.fft)
if outchans != range(n_chans):
self.connect(self.fft, self.selector, self.v2ss)
else:
self.connect(self.fft, self.v2ss)
for i in range(0, len(outchans)):
self.connect((self.v2ss, i), (self, i))
def __init__(self, pfa, pfd, freq, useless_bw, nframes_to_check, nframes_to_average):
gr.top_block.__init__(self)
# Constants
samp_rate = 2.4e6
fft_size = 4096
samples_per_band = 16
tcme = 1.9528
output_pfa = True
debug_stats = False
histogram = True
primary_user_location = 42
nsegs_to_check = 6
downconverter = 1
# Blocks
rtlsdr_source = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
rtlsdr_source.set_sample_rate(samp_rate)
rtlsdr_source.set_center_freq(freq, 0)
rtlsdr_source.set_freq_corr(0, 0)
rtlsdr_source.set_gain_mode(0, 0)
rtlsdr_source.set_gain(10, 0)
rtlsdr_source.set_if_gain(24, 0)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1)
self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram,nframes_to_check,nframes_to_average,downconverter,nsegs_to_check)
self.sink = gr.vector_sink_f()
# Connections
self.connect(rtlsdr_source, s2v, fftb, self.ss, self.sink)
def __init__(self, dpss, fftshift=False):
gr.hier_block2.__init__(self, "eigenspectrum",
gr.io_signature(1, 1, gr.sizeof_gr_complex*len(dpss)),
gr.io_signature(1, 1, gr.sizeof_gr_complex*len(dpss)))
self.window = dpss
self.fft = fft.fft_vcc(len(dpss), True, self.window, fftshift)
self.connect(self, self.fft, self)
def __init__(self, cf):
gr.top_block.__init__(self, "FM radio FFT example")
##################################################
# Blocks
##################################################
self.fft_vxx_0 = fft.fft_vcc(2048, True, (window.rectangular(2048)), True, 1)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, 2048)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*2048, "/home/pradeep/tutorial_btp/fm/out", False)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(2048)
self.RTL820T = osmosdr.source( args="numchan=" + str(1) + " " + "" )
self.RTL820T.set_sample_rate(2.0E6)
self.RTL820T.set_center_freq(cf, 0)
self.RTL820T.set_freq_corr(00, 0)
self.RTL820T.set_dc_offset_mode(0, 0)
self.RTL820T.set_iq_balance_mode(0, 0)
self.RTL820T.set_gain_mode(False, 0)
self.RTL820T.set_gain(0, 0)
self.RTL820T.set_if_gain(00000000000, 0)
self.RTL820T.set_bb_gain(000000000000, 0)
self.RTL820T.set_antenna("", 0)
self.RTL820T.set_bandwidth(0, 0)
##################################################
# Connections
##################################################
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.RTL820T, 0), (self.blocks_stream_to_vector_0, 0))
#self.connect((self.fft_vxx_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_file_sink_0, 0))
def __init__(self, pfa, pfd, freq, useless_bw, nframes_to_check, nframes_to_average):
gr.top_block.__init__(self)
# Constants
samp_rate = 2.4e6
fft_size = 4096
samples_per_band = 16
tcme = 1.9528
output_pfa = False
debug_stats = False
histogram = False
primary_user_location = 20
nsegs_to_check = 6
downconverter = 1
# Blocks
rtlsdr_source = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
rtlsdr_source.set_sample_rate(samp_rate)
rtlsdr_source.set_center_freq(freq, 0)
rtlsdr_source.set_freq_corr(0, 0)
rtlsdr_source.set_gain_mode(0, 0)
rtlsdr_source.set_gain(10, 0)
rtlsdr_source.set_if_gain(24, 0)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1)
self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram,nframes_to_check,nframes_to_average,downconverter,nsegs_to_check)
self.sink = gr.vector_sink_f()
# Connections
self.connect(rtlsdr_source, s2v, fftb, self.ss, self.sink)
def __init__(self, samplerate, bits_per_sec, fftlen):
gr.hier_block2.__init__(
self,
"square_and_fft_sync_cc",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
#this is just the old square-and-fft method
#ais.freqest is simply looking for peaks spaced bits-per-sec apart
self.square = blocks.multiply_cc(1)
self.fftvect = blocks.stream_to_vector(gr.sizeof_gr_complex, fftlen)
self.fft = fft.fft_vcc(fftlen, True, window.rectangular(fftlen), True)
self.freqest = ais.freqest(int(samplerate), int(bits_per_sec), fftlen)
self.repeat = blocks.repeat(gr.sizeof_float, fftlen)
self.fm = analog.frequency_modulator_fc(-1.0 / (float(samplerate) /
(2 * pi)))
self.mix = blocks.multiply_cc(1)
self.connect(self, (self.square, 0))
self.connect(self, (self.square, 1))
#this is the feedforward branch
self.connect(self, (self.mix, 0))
#this is the feedback branch
self.connect(self.square, self.fftvect, self.fft, self.freqest,
self.repeat, self.fm, (self.mix, 1))
#and this is the output
self.connect(self.mix, self)
def __init__(self, n_chans, n_filterbanks=1, taps=None, outchans=None,
atten=100, bw=1.0, tb=0.2, ripple=0.1):
if n_filterbanks > n_chans:
n_filterbanks = n_chans
if outchans is None:
outchans = list(range(n_chans))
gr.hier_block2.__init__(
self, "pfb_channelizer_hier_ccf",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(len(outchans), len(outchans), gr.sizeof_gr_complex))
if taps is None:
taps = self.create_taps(n_chans, atten=100, bw=1.0, tb=0.2, ripple=0.1)
taps = list(taps)
extra_taps = int(math.ceil(1.0*len(taps)/n_chans)*n_chans - len(taps))
taps = taps + [0] * extra_taps
# Make taps for each channel
chantaps = [list(reversed(taps[i: len(taps): n_chans])) for i in range(0, n_chans)]
# Convert the input stream into a stream of vectors.
self.s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, n_chans)
# Create a mapping to separate out each filterbank (a group of channels to be processed together)
# And a list of sets of taps for each filterbank.
low_cpp = int(n_chans / n_filterbanks)
extra = n_chans - low_cpp*n_filterbanks
cpps = [low_cpp+1]*extra + [low_cpp]*(n_filterbanks-extra)
splitter_mapping = []
filterbanktaps = []
total = 0
for cpp in cpps:
splitter_mapping.append([(0, i) for i in range(total, total+cpp)])
filterbanktaps.append(chantaps[total: total+cpp])
total += cpp
assert(total == n_chans)
# Split the stream of vectors in n_filterbanks streams of vectors.
self.splitter = blocks.vector_map(gr.sizeof_gr_complex, [n_chans], splitter_mapping)
# Create the filterbanks
self.fbs = [filter.filterbank_vcvcf(taps) for taps in filterbanktaps]
# Combine the streams of vectors back into a single stream of vectors.
combiner_mapping = [[]]
for i, cpp in enumerate(cpps):
for j in range(cpp):
combiner_mapping[0].append((i, j))
self.combiner = blocks.vector_map(gr.sizeof_gr_complex, cpps, combiner_mapping)
# Add the final FFT to the channelizer.
self.fft = fft.fft_vcc(n_chans, forward=True, window=[1.0]*n_chans)
# Select the desired channels
if outchans != list(range(n_chans)):
selector_mapping = [[(0, i) for i in outchans]]
self.selector = blocks.vector_map(gr.sizeof_gr_complex, [n_chans], selector_mapping)
# Convert stream of vectors to a normal stream.
self.v2ss = blocks.vector_to_streams(gr.sizeof_gr_complex, len(outchans))
self.connect(self, self.s2v, self.splitter)
for i in range(0, n_filterbanks):
self.connect((self.splitter, i), self.fbs[i], (self.combiner, i))
self.connect(self.combiner, self.fft)
if outchans != list(range(n_chans)):
self.connect(self.fft, self.selector, self.v2ss)
else:
self.connect(self.fft, self.v2ss)
for i in range(0, len(outchans)):
self.connect((self.v2ss, i), (self, i))
def test_003_t(self):
# test fft against gnuradio fft
# set up fg
test_len = 1024 * 2
packet_len = test_len
samp_rate = 2000
frequency = (100, 100)
amplitude = 1
src = radar.signal_generator_cw_c(packet_len, samp_rate, frequency,
amplitude)
head = blocks.head(8, test_len)
tsfft = radar.ts_fft_cc(packet_len)
snk1 = blocks.vector_sink_c()
self.tb.connect(src, head, tsfft, snk1)
s2v = blocks.stream_to_vector(8, packet_len)
fft_inbuild = fft.fft_vcc(test_len, 1, fft.window_rectangular(0))
snk2 = blocks.vector_sink_c()
v2s = blocks.vector_to_stream(8, packet_len)
self.tb.connect(head, s2v, fft_inbuild, v2s, snk2)
self.tb.run()
# compaire ffts
data_tsfft = snk1.data()
data_fft_inbuild = snk2.data()
self.assertComplexTuplesAlmostEqual(
data_tsfft, data_fft_inbuild,
2) # compare inbuild fft and fft from block
def __init__(self, auto_carrier, carrier, all_spectrum, freq_central, samp_rate, nintems, signal_bw, noise_bw, avg_alpha, average, win):
"""
Estimates the SNR.
Provide access to the setting the filter and sample rate.
Args:
sample_rate: Incoming stream sample rate
nintems: Number of FFT bins
avg_alpha: FFT averaging (over time) constant [0.0-1.0]
average: Whether to average [True, False]
win: the window taps generation function
auto_carrier: To allow self-detection of the carrier, so the highest bin [True, False]
carrier: To evalutaion of the CNR or SNR [True, False]
all_spectrum: To set the whole spectrum (less the signal's one) to evaluate noise power density [True, False]
freq_central: Sets the central frequency (for the bandwidth) of the signal (in the CNR mode, it is the manual set of the carrier's frequency)
signal_bw: Sets the bandwidth (for the SNR mode) of the signal to the power evaluation
noise_bw: Sets the bandwidth (if all_sepctrum is false) of the noise to the power evaluation
"""
gr.hier_block2.__init__(self, "snr_estimator_cfv",
gr.io_signature(1,1, gr.sizeof_gr_complex), # Input signature
gr.io_signature2(2,2, gr.sizeof_float, gr.sizeof_float * nintems)) # Output signature
self.auto_carrier = auto_carrier
self.carrier = carrier
self.all_spectrum = all_spectrum
self.freq_central = freq_central
self.samp_rate = samp_rate
self.nintems = nintems
self.signal_bw = signal_bw
self.noise_bw = noise_bw
self.avg_alpha = avg_alpha
self.average = average
self.win = win
fft_window = self.win(self.nintems)
self.fft = fft.fft_vcc(self.nintems, True, fft_window, True)
self._sd = blocks.stream_to_vector(gr.sizeof_gr_complex, self.nintems)
self.c2magsq = blocks.complex_to_mag_squared(self.nintems)
self._avg = filter.single_pole_iir_filter_ff(1.0, self.nintems)
self.snr = flaress.snr(self.auto_carrier, self.carrier, self.all_spectrum, self.freq_central, self.samp_rate, self.nintems, self.signal_bw, self.noise_bw)
window_power = sum(map(lambda x: x*x, fft_window))
self.log = blocks.nlog10_ff(10, self.nintems,
-20*math.log10(self.nintems) # Adjust for number of bins
-10*math.log10(float(window_power)/self.nintems) # Adjust for windowing loss
-20*math.log10(float(2)/2)) # Adjust for reference scale
self.connect(self, self._sd, self.fft, self.c2magsq, self._avg, self.snr, (self, 0))
self.connect(self._avg, self.log, (self, 1))
self._average = average
self._avg_alpha = avg_alpha
self.set_avg_alpha(avg_alpha)
self.set_average(average)
def __init__(self, window_size):
gr.hier_block2.__init__(self, "FFT_IFFT",
gr.io_signature(1, 1, gr.sizeof_float),
gr.io_signature(1, 1, gr.sizeof_float))
vector_to_stream = blocks.vector_to_stream(gr.sizeof_gr_complex,
window_size)
stream_to_vector = blocks.stream_to_vector(gr.sizeof_float,
window_size)
divide = blocks.divide_cc(1)
complex_to_float = blocks.complex_to_float(1)
fft_forward = fft.fft_vfc(window_size, True,
(fft.window.blackmanharris(window_size)),
1)
fft_backward = fft.fft_vcc(
window_size, False, (fft.window.blackmanharris(window_size)),
False, 1)
constant = analog.sig_source_c(0, analog.GR_CONST_WAVE, 0, 0,
window_size)
#print("1. Connect self to stream_to_vector")
self.connect((self, 0), (stream_to_vector, 0))
#print("2. Connect stream_to_vector to fft_forward")
self.connect((stream_to_vector, 0), (fft_forward, 0))
#print("3. Connect fft_forward to fft_backward")
self.connect((fft_forward, 0), (fft_backward, 0))
#print("4. Connect fft_backward to vector_to_stream")
self.connect((fft_backward, 0), (vector_to_stream, 0))
#print("5. Connect vector_to_stream to port 0 of divide")
self.connect((vector_to_stream, 0), (divide, 0))
#print("6. Connect constant to port 1 of divide")
self.connect(constant, (divide, 1))
#print("7. Connect divide to complex_to_float")
self.connect((divide, 0), (complex_to_float, 0))
#print("8. Connect complex_to_float to self")
self.connect((complex_to_float, 0), (self, 0))
def __init__(self, parent, baseband_freq=0,
y_per_div=10, ref_level=50, sample_rate=1, fft_size=512,
fft_rate=default_fft_rate, average=False, avg_alpha=None,
title='', size=default_fftsink_size, **kwargs):
gr.hier_block2.__init__(self, "waterfall_sink_f",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0,0,0))
waterfall_sink_base.__init__(self, input_is_real=False, baseband_freq=baseband_freq,
sample_rate=sample_rate, fft_size=fft_size,
fft_rate=fft_rate,
average=average, avg_alpha=avg_alpha, title=title)
self.s2p = gr.serial_to_parallel(gr.sizeof_gr_complex, self.fft_size)
self.one_in_n = gr.keep_one_in_n(gr.sizeof_gr_complex * self.fft_size,
max(1, int(self.sample_rate/self.fft_size/self.fft_rate)))
mywindow = window.blackmanharris(self.fft_size)
self.fft = fft.fft_vcc(self.fft_size, True, mywindow)
self.c2mag = gr.complex_to_mag(self.fft_size)
self.avg = filter.single_pole_iir_filter_ff(1.0, self.fft_size)
self.log = gr.nlog10_ff(20, self.fft_size, -20*math.log10(self.fft_size))
self.sink = gr.message_sink(gr.sizeof_float * self.fft_size, self.msgq, True)
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag, self.avg, self.log, self.sink)
self.win = waterfall_window(self, parent, size=size)
self.set_average(self.average)
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 1e6
self.freq = freq = 2e9
##################################################
# Blocks
##################################################
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.GetWin(),
baseband_freq=freq,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=1024,
fft_rate=15,
average=False,
avg_alpha=None,
title='FFT Plot',
peak_hold=False,
)
self.Add(self.wxgui_fftsink2_0.win)
self.uhd_usrp_source_0 = uhd.usrp_source(
",".join(("", "")),
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(freq, 0)
self.uhd_usrp_source_0.set_gain(10, 0)
self.uhd_usrp_source_0.set_antenna('RX2', 0)
self.fft_vxx_0 = fft.fft_vcc(1024, True, (window.blackmanharris(1024)),
True, 1)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(
gr.sizeof_gr_complex * 1, 1024)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float * 1024,
'/home/prabhat/a', False)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(
1024)
##################################################
# Connections
##################################################
self.connect((self.blocks_complex_to_mag_squared_0, 0),
(self.blocks_file_sink_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.fft_vxx_0, 0),
(self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.uhd_usrp_source_0, 0),
(self.blocks_stream_to_vector_0, 0))
self.connect((self.uhd_usrp_source_0, 0), (self.wxgui_fftsink2_0, 0))
def __init__(self, sample_rate, fft_size, ref_scale, frame_rate):
gr.hier_block2.__init__(
self, "logpowerfft_win", gr.io_signature(1, 1,
gr.sizeof_gr_complex),
gr.io_signature(1, 1, gr.sizeof_float * fft_size))
self._sd = blocks.stream_to_vector_decimator(
item_size=gr.sizeof_gr_complex,
sample_rate=sample_rate,
vec_rate=frame_rate,
vec_len=fft_size)
fft_window = fft_lib.window_hamming(fft_size)
fft = fft_lib.fft_vcc(fft_size, True, fft_window, True)
window_power = sum([x * x for x in fft_window])
c2magsq = blocks.complex_to_mag_squared(fft_size)
self._avg = filter.single_pole_iir_filter_ff(1.0, fft_size)
self._log = blocks.nlog10_ff(
10,
fft_size,
-20 * math.log10(fft_size) # Adjust for number of bins
- 10 * math.log10(
float(window_power) / fft_size) # Adjust for windowing loss
- 20 *
math.log10(float(ref_scale) / 2)) # Adjust for reference scale
self.connect(self, self._sd, fft, c2magsq, self._avg, self._log, self)
def test_multithreaded(self):
nthreads = nthreads_min
while nthreads < nthreads_max:
fft_size_pow = fft_size_pow_min
while fft_size_pow < fft_size_pow_max:
self.fft_size = 2**fft_size_pow
print "fft_size:\t%d" % self.fft_size
print "nthreads:\t%d" % nthreads
src_data = tuple(
[x / self.fft_size for x in primes_transformed])
#expected_result = tuple([complex(primes[2 * i], primes[2 * i + 1]) for i in range(self.fft_size)])
src = blocks.vector_source_c(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_gr_complex,
self.fft_size)
op = fft.fft_vcc(self.fft_size, True, [], False, nthreads)
v2s = blocks.vector_to_stream(gr.sizeof_gr_complex,
self.fft_size)
dst = blocks.vector_sink_c()
self.tb.connect(src, s2v, op, v2s, dst)
start = time.time()
self.tb.run()
end = time.time()
totaltime = end - start
print "execTime: %6.6f" % totaltime
#print(op.pc_work_time())
# print(op.pc_noutput_items_var())
result_data = dst.data()
#self.assert_fft_ok2(expected_result, result_data)
fft_size_pow = fft_size_pow + 1
nthreads = nthreads + 1
def test_003_t (self): # test fft against gnuradio fft # set up fg test_len = 1024*2 packet_len = test_len samp_rate = 2000 frequency = (100,100) amplitude = 1 src = radar.signal_generator_cw_c(packet_len,samp_rate,frequency,amplitude) head = blocks.head(8,test_len) tsfft = radar.ts_fft_cc(packet_len) snk1 = blocks.vector_sink_c() self.tb.connect(src,head,tsfft,snk1) s2v = blocks.stream_to_vector(8, packet_len) fft_inbuild = fft.fft_vcc(test_len,True,fft.window_rectangular(0)) snk2 = blocks.vector_sink_c() v2s = blocks.vector_to_stream(8, packet_len); self.tb.connect(head,s2v,fft_inbuild,v2s,snk2) self.tb.run() # compaire ffts data_tsfft = snk1.data() data_fft_inbuild = snk2.data() self.assertComplexTuplesAlmostEqual(data_tsfft,data_fft_inbuild,2) # compare inbuild fft and fft from block
def __init__(self, fft_size, mavg_size, ed_threshold):
"""
CTOR
@param fft_size FFT Size
@param mavg_size Energy Detector mavg size.
"""
gr.hier_block2.__init__(
self,
name="simple_ranking_detector",
input_signature=gr.io_signature(1, 1, gr.sizeof_gr_complex),
output_signature=gr.io_signature(2, 2, gr.sizeof_float),
)
# Blocks
# Convert the output of a FFT
self.s2v_0 = blocks.stream_to_vector(gr.sizeof_gr_complex, fft_size)
self.fft_0 = fft.fft_vcc(fft_size, True, [])
self.c2mag_0 = blocks.complex_to_mag_squared(fft_size)
# Instantiate the energy calculator
from sensing import EnergyDecision
self.ql = QLearningWorker(fft_size, algorithm=EnergyDecision(ed_threshold))
#::TODO:: parece que nao tem mais o metodo connect
# Flow graph
self.connect(self, self.s2v_0, self.fft_0, self.c2mag_0, self.ql)
self.connect((self.ql, 0), (self, 0))
self.connect((self.ql, 1), (self, 1))
def __init__(self, fft_len, rate, sample_rate):
gr.hier_block2.__init__(self,
"psd_logger",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0,0,0))
self.fft_len = fft_len
self.rate = rate
self.sample_rate = sample_rate
self.msgq = gr.msg_queue(2)
self.log_file = open('/tmp/psd_log'+'-'+ time.strftime("%y%m%d") + '-' + time.strftime("%H%M%S"),'w')
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, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
self.c2mag = blocks.complex_to_mag(self.fft_len)
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq, True)
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag, self.sink)
self._watcher = _queue_watcher(self.msgq, self.log_file)
def ms_to_file(hb,block,filename,N=4096,delay=0,fft=False,scale=1):
streamsize = determine_streamsize(block)
vlen = streamsize/gr.sizeof_gr_complex
blks = [block]
if fft and vlen > 1:
gr_fft = fft_blocks.fft_vcc(vlen,True,[],True)
blks.append(gr_fft)
mag_sqrd = gr.complex_to_mag_squared(vlen)
blks.append(mag_sqrd)
if vlen > 1:
v2s = blocks.vector_to_stream(gr.sizeof_float,vlen)
blks.append(v2s)
if delay != 0:
delayline = delayline_ff(delay)
blks.append(delayline)
gr_scale = gr.multiply_const_ff(scale)
blks.append(gr_scale)
filter = gr.fir_filter_fff(1,[1.0/N]*N)
blks.append(filter)
for i in range(len(blks)-1):
hb.connect(blks[i],blks[i+1])
log_to_file(hb,filter,filename)
def __init__(self, ber_block, ncorrelations, lfsr_bits = 16):
gr.top_block.__init__(self)
prn_len = 2**lfsr_bits
prn = np.concatenate((scipy.signal.max_len_seq(lfsr_bits)[0], [1]))
prn_fft_conj = np.conjugate(np.fft.fft(2*prn-1))
self.source = blocks.vector_source_b(prn, True, 1, [])
self.ber_block = ber_block
self.char2float = blocks.char_to_float(1, 0.5)
self.add_const = blocks.add_const_ff(-1.0)
self.source_vector = blocks.stream_to_vector(gr.sizeof_float, prn_len)
self.fft = fft.fft_vfc(prn_len, True, window.rectangular(prn_len), 1)
self.prn_fft_source = blocks.vector_source_c(prn_fft_conj, True, prn_len, [])
self.multiply_ffts = blocks.multiply_vcc(prn_len)
self.ifft = fft.fft_vcc(prn_len, False, np.ones(prn_len)/prn_len**2, False, 1)
self.corr_mag = blocks.complex_to_mag(prn_len)
self.max_corr = blocks.max_ff(prn_len, 1)
self.multiply_const = blocks.multiply_const_ff(-0.5)
self.add_const2 = blocks.add_const_ff(0.5)
self.head = blocks.head(gr.sizeof_float, ncorrelations)
self.sink = blocks.vector_sink_f()
self.connect(self.source, self.ber_block, self.char2float, self.add_const,
self.source_vector, self.fft, (self.multiply_ffts,0),
self.ifft, self.corr_mag, self.max_corr, self.multiply_const,
self.add_const2, self.head, self.sink)
self.connect(self.prn_fft_source, (self.multiply_ffts,1))
def __init__(self, dbW, pfa, pfd):
gr.top_block.__init__(self)
# Parameters
samp_rate = 2e6
fft_size = 4096
samples_per_band = 16
tcme = 1.9528
output_pfa = True
debug_stats = False
primary_user_location = 0
useless_bw = 0.0 # As we are not using any of the dongles it can be set as zero, i.e., all the band can be used.
histogram = False
nframes_to_check = 1
nframes_to_average = 1
downconverter = 1
nsegs_to_check = 6
# Create AWGN noise
noise = awgn(fft_size, dbW)
# Blocks
src = gr.vector_source_c(noise)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1)
self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram,nframes_to_check,nframes_to_average,downconverter,nsegs_to_check)
self.sink = gr.vector_sink_f()
# Connections
self.connect(src, s2v, fftb, self.ss, self.sink)
def _test_window(self):
src_data = tuple([
complex(primes[2 * i], primes[2 * i + 1])
for i in range(self.fft_size)
])
expected_result = (
(2238.9174 + 2310.4750j), (-1603.7416 - 466.7420j),
(116.7449 - 70.8553j), (-13.9157 + 19.0855j), (-4.8283 + 16.7025j),
(-43.7425 + 16.9871j), (-16.1904 + 1.7494j), (-32.3797 + 6.9964j),
(-13.5283 + 7.7721j), (-24.3276 - 7.5378j), (-29.2711 + 4.5709j),
(-2.7124 - 6.6307j), (-33.5486 - 8.3485j), (-8.3016 - 9.9534j),
(-18.8590 - 8.3501j), (-13.9092 - 1.1396j), (-17.7626 - 26.9281j),
(0.0182 - 8.9000j), (-19.9143 - 14.1320j), (-10.3073 - 15.5759j),
(3.5800 - 29.1835j), (-7.5263 - 1.5900j), (-3.0392 - 31.7445j),
(-15.1355 - 33.6158j), (28.2345 - 11.4373j), (-6.0055 - 27.0418j),
(5.2074 - 21.2431j), (23.1617 - 31.8610j), (13.6494 - 11.1982j),
(14.7145 - 14.4113j), (-60.0053 + 114.7418j), (-440.1561 -
1632.9807j))
window = fft.window_hamming(ntaps=self.fft_size)
src = blocks.vector_source_c(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
op = fft.fft_vcc(self.fft_size, True, window, False)
v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, self.fft_size)
dst = blocks.vector_sink_c()
self.tb.connect(src, s2v, op, v2s, dst)
self.tb.run()
result_data = dst.data()
def __init__(self, fft_len, sample_rate, tune_freq, average, rate, length, 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.length = length 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.length, self.height)
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
if width == 0 and height == 0:
rows, columns = os.popen('stty size', 'r').read().split()
self.height = int(rows) - 5
self.width = int(columns) / 2 - 10
else:
self.height = height
self.width = width
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(self.average,
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)
#register message out to other blocks
self.message_port_register_hier_out("pkt_out")
#packet generator
self.packet_generator = of.chat_blocks.chat_sender()
#####CONNECTIONS####
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2,
self.avg, self.log, self.sink)
#MSG output
self.msg_connect(self.packet_generator, "out", self, "pkt_out")
####THREADS####
self._ascii_plotter = ascii_plotter(self.width, self.height,
self.tune_freq, self.sample_rate,
self.fft_len)
self._main = main_thread(self.msgq, self._ascii_plotter,
self.packet_generator)
def __init__(self, yaml_config):
super(DarkflowFlowGraph, self).__init__()
# params
self.yaml_config = yaml_config
sample_rate = 20.0e6
centre_freq = 3.5e9
gaindB = 30
# flowgraph blocks
self.usrp_source = uhd.usrp_source(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.usrp_source.set_samp_rate(sample_rate)
self.usrp_source.set_center_freq(centre_freq, 0)
self.usrp_source.set_gain(gaindB, 0)
self.toparallel = blocks.stream_to_vector(gr.sizeof_gr_complex, 64)
self.fftblock = fft.fft_vcc(64, True,
signal.get_window(('tukey', 0.25), 64),
True)
self.mag2 = blocks.complex_to_mag_squared(64)
self.classifier = darkflow_ckpt_classifier_c(self.yaml_config, 64,
True, 10, 10000)
# self.tostream = blocks.vector_to_stream(gr.sizeof_float,64)
# self.null_sink = blocks.null_sink(gr.sizeof_float)
# make flowgraph
self.connect(self.usrp_source, self.toparallel)
self.connect(self.toparallel, self.fftblock)
self.connect(self.fftblock, self.mag2)
self.connect(self.mag2, self.classifier)
def __init__(self, sample_rate, fac_size, fac_rate):
gr.hier_block2.__init__(self, "fast_autocorrelator_c",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(1, 1, gr.sizeof_float))
# Parameters
self.sample_rate = sample_rate
self.fac_size = fac_size
self.fac_rate = fac_rate
self.window = ()
# Block Objects For Complex Fast Autocorrelator
self.stream_to_vector = blocks.stream_to_vector(
gr.sizeof_gr_complex, fac_size)
self.keep_one_in_n = blocks.keep_one_in_n(
gr.sizeof_gr_complex * fac_size,
max(1, int(sample_rate / fac_size / fac_rate)))
self.fac_fft = fft.fft_vfc(fac_size, True, self.window)
self.complex_to_mag = blocks.complex_to_mag(fac_size)
self.fac_complex_to_mag = blocks.complex_to_mag(fac_size)
self.nlog10_ff = blocks.nlog10_ff(20, fac_size,
-20 * math.log10(fac_size))
self.single_pole_iir_filter_ff = filter.single_pole_iir_filter_ff(
1.0, fac_size)
self.fft_vcc = fft.fft_vcc(fac_size, True, self.window)
self.vector_to_stream = blocks.vector_to_stream(
gr.sizeof_float, self.fac_size)
# Connections for Auto Correlator
self.connect(self, self.stream_to_vector, self.keep_one_in_n,
self.fft_vcc, self.complex_to_mag, self.fac_fft,
self.fac_complex_to_mag, self.single_pole_iir_filter_ff,
self.nlog10_ff, self.vector_to_stream, self)
def __init__(self, bandwidth=2e6, bb_gain=20, channels=1024, dev_args='', duration=60, frequency=1420e6, if_gain=20, obs_file='observation.dat', rf_gain=30, t_sample=1):
gr.top_block.__init__(self, "Run Observation")
##################################################
# Parameters
##################################################
self.bandwidth = bandwidth
self.bb_gain = bb_gain
self.channels = channels
self.dev_args = dev_args
self.duration = duration
self.frequency = frequency
self.if_gain = if_gain
self.obs_file = obs_file
self.rf_gain = rf_gain
self.t_sample = t_sample
##################################################
# Variables
##################################################
self.sinc_sample_locations = sinc_sample_locations = np.arange(-np.pi*4/2.0, np.pi*4/2.0, np.pi/channels)
self.sinc = sinc = np.sinc(sinc_sample_locations/np.pi)
self.custom_window = custom_window = sinc*np.hamming(4*channels)
##################################################
# Blocks
##################################################
self.osmosdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + dev_args )
self.osmosdr_source_0.set_sample_rate(bandwidth)
self.osmosdr_source_0.set_center_freq(frequency, 0)
self.osmosdr_source_0.set_freq_corr(0, 0)
self.osmosdr_source_0.set_dc_offset_mode(0, 0)
self.osmosdr_source_0.set_iq_balance_mode(0, 0)
self.osmosdr_source_0.set_gain_mode(False, 0)
self.osmosdr_source_0.set_gain(rf_gain, 0)
self.osmosdr_source_0.set_if_gain(if_gain, 0)
self.osmosdr_source_0.set_bb_gain(bb_gain, 0)
self.osmosdr_source_0.set_antenna('', 0)
self.osmosdr_source_0.set_bandwidth(0, 0)
self.fft_vxx_0 = fft.fft_vcc(channels, True, (window.blackmanharris(channels)), True, 1)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, channels)
self.blocks_integrate_xx_0 = blocks.integrate_ff(int(t_sample*bandwidth/channels), channels)
self.blocks_head_0 = blocks.head(gr.sizeof_gr_complex*1, int(duration*bandwidth))
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*channels, obs_file, True)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(channels)
##################################################
# Connections
##################################################
self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_integrate_xx_0, 0))
self.connect((self.blocks_head_0, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.blocks_integrate_xx_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.osmosdr_source_0, 0), (self.blocks_head_0, 0))
def __init__(self, dpss, fftshift=False):
gr.hier_block2.__init__(self, "eigenspectrum",
gr.io_signature(1, 1, gr.sizeof_gr_complex*len(dpss)),
gr.io_signature(1, 1, gr.sizeof_float*len(dpss)))
self.window = dpss
self.fft = fft.fft_vcc(len(dpss), True, self.window, fftshift)
self.c2mag = blocks.complex_to_mag_squared(len(dpss))
self.connect(self, self.fft, self.c2mag, self)
def create_ofdm_blocks(self):
self.carrier_allocator = digital.ofdm_carrier_allocator_cvc(
self.fft_len, self.occupied_carriers, self.pilot_carriers,
self.pilot_symbols, self.sync_words, self.len_tag_key)
self.ifft = fft.fft_vcc(self.fft_len, False, (), True, 1)
ofdm_len = self.fft_len + self.cp_len
self.ofdm_cyclic_prefixer = digital.ofdm_cyclic_prefixer(
self.fft_len, ofdm_len, 0, self.len_tag_key)
def __init__(self, fft_len, cp_len, occupied_carriers, pilot_carriers,
pilot_symbols, constellation, nofdm_symbols, packet_len_tag):
gr.hier_block2.__init__(
self, "ofdm_frame_to_symbols_vcc",
gr.io_signature(1, 1, fft_len * gr.sizeof_gr_complex),
gr.io_signature(1, 1, gr.sizeof_gr_complex))
self.fft_len = fft_len
self.cp_len = cp_len
self.occupied_carriers = occupied_carriers
self.pilot_carriers = pilot_carriers
self.pilot_symbols = pilot_symbols
self.constellation = constellation
self.nofdm_symbols = nofdm_symbols
self.packet_len_tag = packet_len_tag
self.frame_len_tag_key = "frame_length"
self.fft_payload = fft.fft_vcc(fft_size=self.fft_len,
forward=True,
window=(),
shift=True)
self.chanest = digital.ofdm_chanest_vcvc(
sync_symbol1=utils.ofdm_make_sync_word1(self.fft_len,
self.occupied_carriers,
self.pilot_carriers),
sync_symbol2=utils.ofdm_make_sync_word2(self.fft_len,
self.occupied_carriers,
self.pilot_carriers),
n_data_symbols=self.nofdm_symbols)
self.payload_equalizer = digital.ofdm_equalizer_simpledfe(
fft_len=self.fft_len,
constellation=self.constellation.base(),
occupied_carriers=self.occupied_carriers,
pilot_carriers=self.pilot_carriers,
pilot_symbols=self.pilot_symbols,
symbols_skipped=0)
self.payload_eq = digital.ofdm_frame_equalizer_vcvc(
equalizer=self.payload_equalizer.base(),
cp_len=cp_len,
len_tag_key=self.frame_len_tag_key,
propagate_channel_state=True,
fixed_frame_len=self.nofdm_symbols)
# doesn't accept names of parameters
self.payload_serializer = digital.ofdm_serializer_vcc(
self.fft_len, # fft_len =
self.occupied_carriers, # occupied_carriers =
self.frame_len_tag_key, # len_tag_key =
self.packet_len_tag, # packet_len_tag =
0 # symbolsskipped =
)
self.connect(self, self.fft_payload, self.chanest, self.payload_eq,
self.payload_serializer, self)
def __init__(self):
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))
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
self.rational_resampler_xxx_0 = filter.rational_resampler_ccc(
interpolation=70,
decimation=64,
taps=None,
fractional_bw=None,
)
self.osmosdr_sink_0 = osmosdr.sink( args="numchan=" + str(1) + " " + "bladerf=0,buffers=128,buflen=32768" )
self.osmosdr_sink_0.set_sample_rate(10e6)
self.osmosdr_sink_0.set_center_freq(800e6, 0)
self.osmosdr_sink_0.set_freq_corr(0, 0)
self.osmosdr_sink_0.set_gain(19, 0)
self.osmosdr_sink_0.set_if_gain(0, 0)
self.osmosdr_sink_0.set_bb_gain(0, 0)
self.osmosdr_sink_0.set_antenna("", 0)
self.osmosdr_sink_0.set_bandwidth(0, 0)
self.fft_vxx_0 = fft.fft_vcc(2048, False, (window.rectangular(2048)), True, 10)
self.dvbt_symbol_inner_interleaver_0 = dvbt.symbol_inner_interleaver(1512, dvbt.T2k, 1)
self.dvbt_reference_signals_0 = dvbt.reference_signals(gr.sizeof_gr_complex, 1512, 2048, dvbt.QAM16, dvbt.NH, dvbt.C1_2, dvbt.C1_2, dvbt.G1_32, dvbt.T2k, 0, 0)
self.dvbt_reed_solomon_enc_0 = dvbt.reed_solomon_enc(2, 8, 0x11d, 255, 239, 8, 51, 8)
self.dvbt_inner_coder_0 = dvbt.inner_coder(1, 1512, dvbt.QAM16, dvbt.NH, dvbt.C1_2)
self.dvbt_energy_dispersal_0 = dvbt.energy_dispersal(1)
self.dvbt_dvbt_map_0 = dvbt.dvbt_map(1512, dvbt.QAM16, dvbt.NH, dvbt.T2k, 1)
self.dvbt_convolutional_interleaver_0 = dvbt.convolutional_interleaver(136, 12, 17)
self.dvbt_bit_inner_interleaver_0 = dvbt.bit_inner_interleaver(1512, dvbt.QAM16, dvbt.NH, dvbt.T2k)
self.digital_ofdm_cyclic_prefixer_0 = digital.ofdm_cyclic_prefixer(2048, 2048+64, 0, "")
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc((0.0022097087, ))
self.blocks_file_source_0 = blocks.file_source(gr.sizeof_char*1, "test.ts", True)
##################################################
# Connections
##################################################
self.connect((self.blocks_file_source_0, 0), (self.dvbt_energy_dispersal_0, 0))
self.connect((self.blocks_multiply_const_vxx_0, 0), (self.rational_resampler_xxx_0, 0))
self.connect((self.digital_ofdm_cyclic_prefixer_0, 0), (self.blocks_multiply_const_vxx_0, 0))
self.connect((self.dvbt_bit_inner_interleaver_0, 0), (self.dvbt_symbol_inner_interleaver_0, 0))
self.connect((self.dvbt_convolutional_interleaver_0, 0), (self.dvbt_inner_coder_0, 0))
self.connect((self.dvbt_dvbt_map_0, 0), (self.dvbt_reference_signals_0, 0))
self.connect((self.dvbt_energy_dispersal_0, 0), (self.dvbt_reed_solomon_enc_0, 0))
self.connect((self.dvbt_inner_coder_0, 0), (self.dvbt_bit_inner_interleaver_0, 0))
self.connect((self.dvbt_reed_solomon_enc_0, 0), (self.dvbt_convolutional_interleaver_0, 0))
self.connect((self.dvbt_reference_signals_0, 0), (self.fft_vxx_0, 0))
self.connect((self.dvbt_symbol_inner_interleaver_0, 0), (self.dvbt_dvbt_map_0, 0))
self.connect((self.fft_vxx_0, 0), (self.digital_ofdm_cyclic_prefixer_0, 0))
self.connect((self.rational_resampler_xxx_0, 0), (self.osmosdr_sink_0, 0))
def __init__(self):
gr.top_block.__init__(self, "Hd Tx Rtl File")
##################################################
# Blocks
##################################################
self.rational_resampler_xxx_1 = filter.rational_resampler_ccc(
interpolation=2,
decimation=1,
taps=None,
fractional_bw=None)
self.nrsc5_sis_encoder_0 = nrsc5.sis_encoder('ABCD')
self.nrsc5_psd_encoder_0 = nrsc5.psd_encoder(0, 'Title', 'Artist')
self.nrsc5_l2_encoder_0 = nrsc5.l2_encoder(1, 0, 146176)
self.nrsc5_l1_fm_encoder_mp1_0 = nrsc5.l1_fm_encoder(1)
self.nrsc5_hdc_encoder_0 = nrsc5.hdc_encoder(2, 64000)
self.fft_vxx_0 = fft.fft_vcc(2048, False, window.rectangular(2048), True, 1)
self.blocks_wavfile_source_0 = blocks.wavfile_source('sample.wav', True)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_gr_complex*1, 2048)
self.blocks_vector_source_x_0 = blocks.vector_source_c([math.sin(math.pi / 2 * i / 112) for i in range(112)] + [1] * (2048-112) + [math.cos(math.pi / 2 * i / 112) for i in range(112)], True, 1, [])
self.blocks_repeat_0 = blocks.repeat(gr.sizeof_gr_complex*2048, 2)
self.blocks_multiply_xx_0 = blocks.multiply_vcc(1)
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_cc(0.5)
self.blocks_keep_m_in_n_0 = blocks.keep_m_in_n(gr.sizeof_gr_complex, 2160, 4096, 0)
self.blocks_interleave_0 = blocks.interleave(gr.sizeof_float*1, 1)
self.blocks_float_to_uchar_0 = blocks.float_to_uchar()
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_char*1, 'hd-generated.raw', False)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_conjugate_cc_0 = blocks.conjugate_cc()
self.blocks_complex_to_float_0 = blocks.complex_to_float(1)
self.blocks_add_const_vxx_0_0 = blocks.add_const_ff(127.5)
##################################################
# Connections
##################################################
self.connect((self.blocks_add_const_vxx_0_0, 0), (self.blocks_float_to_uchar_0, 0))
self.connect((self.blocks_complex_to_float_0, 0), (self.blocks_interleave_0, 0))
self.connect((self.blocks_complex_to_float_0, 1), (self.blocks_interleave_0, 1))
self.connect((self.blocks_conjugate_cc_0, 0), (self.rational_resampler_xxx_1, 0))
self.connect((self.blocks_float_to_uchar_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.blocks_interleave_0, 0), (self.blocks_add_const_vxx_0_0, 0))
self.connect((self.blocks_keep_m_in_n_0, 0), (self.blocks_multiply_xx_0, 1))
self.connect((self.blocks_multiply_const_vxx_0, 0), (self.blocks_complex_to_float_0, 0))
self.connect((self.blocks_multiply_xx_0, 0), (self.blocks_conjugate_cc_0, 0))
self.connect((self.blocks_repeat_0, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.blocks_vector_source_x_0, 0), (self.blocks_multiply_xx_0, 0))
self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_keep_m_in_n_0, 0))
self.connect((self.blocks_wavfile_source_0, 1), (self.nrsc5_hdc_encoder_0, 1))
self.connect((self.blocks_wavfile_source_0, 0), (self.nrsc5_hdc_encoder_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_repeat_0, 0))
self.connect((self.nrsc5_hdc_encoder_0, 0), (self.nrsc5_l2_encoder_0, 0))
self.connect((self.nrsc5_l1_fm_encoder_mp1_0, 0), (self.fft_vxx_0, 0))
self.connect((self.nrsc5_l2_encoder_0, 0), (self.nrsc5_l1_fm_encoder_mp1_0, 0))
self.connect((self.nrsc5_psd_encoder_0, 0), (self.nrsc5_l2_encoder_0, 1))
self.connect((self.nrsc5_sis_encoder_0, 0), (self.nrsc5_l1_fm_encoder_mp1_0, 1))
self.connect((self.rational_resampler_xxx_1, 0), (self.blocks_multiply_const_vxx_0, 0))
def __init__(self,
max_freq_offset=10,
guard=0.125,
mode=3,
snr=10,
tmcc_print=False):
gr.hier_block2.__init__(
# self, "ISDB-T RF Channel Decoding",
self,
"isdbt_rf_channel_decoding",
gr.io_signature(1, 1, gr.sizeof_gr_complex * 1),
gr.io_signaturev(2, 2, [
gr.sizeof_gr_complex * 13 * 96 * 2**(mode - 1),
gr.sizeof_gr_complex * (13 * 108 * 2**(mode - 1) + 1)
]),
)
##################################################
# Parameters
##################################################
self.max_freq_offset = max_freq_offset
self.guard = guard
self.mode = mode
self.snr = snr
self.tmcc_print = tmcc_print
##################################################
# Variables
##################################################
self.total_carriers = total_carriers = 2**(10 + mode)
self.data_carriers = data_carriers = 13 * 96 * 2**(mode - 1)
self.active_carriers = active_carriers = 13 * 108 * 2**(mode - 1) + 1
##################################################
# Blocks
##################################################
self.isdbt_tmcc_decoder_0 = isdbt.tmcc_decoder(mode, tmcc_print)
self.isdbt_sync_and_channel_estimaton_0 = isdbt.sync_and_channel_estimaton(
total_carriers, active_carriers, max_freq_offset)
self.isdbt_ofdm_sym_acquisition_0 = isdbt.ofdm_sym_acquisition(
total_carriers, int(guard * total_carriers), snr)
self.fft_vxx_0 = fft.fft_vcc(total_carriers, True,
(window.rectangular(total_carriers)),
True, 1)
##################################################
# Connections
##################################################
self.connect((self.fft_vxx_0, 0),
(self.isdbt_sync_and_channel_estimaton_0, 0))
self.connect((self.isdbt_ofdm_sym_acquisition_0, 0),
(self.fft_vxx_0, 0))
self.connect((self.isdbt_sync_and_channel_estimaton_0, 0),
(self.isdbt_tmcc_decoder_0, 0))
self.connect((self.isdbt_sync_and_channel_estimaton_0, 1), (self, 1))
self.connect((self.isdbt_tmcc_decoder_0, 0), (self, 0))
self.connect((self, 0), (self.isdbt_ofdm_sym_acquisition_0, 0))
def __init__(self,
fft_len,
cp_len,
occupied_carriers,
pilot_carriers,
pilot_symbols,
packet_len_tag,
verbose=False):
gr.hier_block2.__init__(
self, "ofdm_symbols_to_frame_cvc",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(1, 1, fft_len * gr.sizeof_gr_complex))
self.fft_len = fft_len
self.cp_len = cp_len
self.occupied_carriers = occupied_carriers
self.pilot_carriers = pilot_carriers
self.pilot_symbols = pilot_symbols
self.packet_len_tag = packet_len_tag
self.allocator = digital.ofdm_carrier_allocator_cvc(
fft_len=self.fft_len,
occupied_carriers=self.occupied_carriers,
pilot_carriers=self.pilot_carriers,
pilot_symbols=self.pilot_symbols,
sync_words=[
utils.ofdm_make_sync_word1(self.fft_len,
self.occupied_carriers,
self.pilot_carriers),
utils.ofdm_make_sync_word2(self.fft_len,
self.occupied_carriers,
self.pilot_carriers),
],
len_tag_key=self.packet_len_tag)
self.ffter = fft.fft_vcc(fft_size=self.fft_len,
forward=False,
window=(),
shift=True)
self.connect(self, self.allocator, self.ffter, self)
if verbose == True:
self.connect(
self,
blocks.file_sink(itemsize=gr.sizeof_gr_complex,
filename='ofdm_symbols_to_frame_input.gr'))
self.connect(
self.allocator,
blocks.file_sink(
itemsize=self.fft_len * gr.sizeof_gr_complex,
filename='ofdm_symbols_to_frame_allocator.gr'))
self.connect(
self.ffter,
blocks.file_sink(itemsize=self.fft_len * gr.sizeof_gr_complex,
filename='ofdm_symbols_to_frame_ffter.gr'))
def __init__(self, fft_len, cp_len,
occupied_carriers, pilot_carriers, pilot_symbols,
packet_len_tag, verbose=False):
gr.hier_block2.__init__(
self,
"ofdm_symbols_to_frame_cvc",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(1, 1, fft_len*gr.sizeof_gr_complex)
)
self.fft_len = fft_len
self.cp_len = cp_len
self.occupied_carriers = occupied_carriers
self.pilot_carriers = pilot_carriers
self.pilot_symbols = pilot_symbols
self.packet_len_tag = packet_len_tag
self.allocator = digital.ofdm_carrier_allocator_cvc(
fft_len=self.fft_len,
occupied_carriers=self.occupied_carriers,
pilot_carriers=self.pilot_carriers,
pilot_symbols=self.pilot_symbols,
sync_words=[
utils.ofdm_make_sync_word1(self.fft_len,
self.occupied_carriers,
self.pilot_carriers),
utils.ofdm_make_sync_word2(self.fft_len,
self.occupied_carriers,
self.pilot_carriers),
],
len_tag_key=self.packet_len_tag
)
self.ffter = fft.fft_vcc(
fft_size=self.fft_len,
forward=False,
window=(),
shift=True
)
self.connect(self, self.allocator, self.ffter, self)
if verbose==True:
self.connect(self, blocks.file_sink(
itemsize=gr.sizeof_gr_complex,
filename='ofdm_symbols_to_frame_input.gr')
)
self.connect(self.allocator, blocks.file_sink(
itemsize=self.fft_len*gr.sizeof_gr_complex,
filename='ofdm_symbols_to_frame_allocator.gr')
)
self.connect(self.ffter, blocks.file_sink(
itemsize=self.fft_len*gr.sizeof_gr_complex,
filename='ofdm_symbols_to_frame_ffter.gr')
)
def __init__(self, fft_size=4096):
gr.hier_block2.__init__(
self, "Fast Autocor",
gr.io_signature(1, 1, gr.sizeof_gr_complex*1),
gr.io_signature(1, 1, gr.sizeof_float*1),
)
##################################################
# Parameters
##################################################
self.fft_size = fft_size
##################################################
# Blocks
##################################################
self.fft_vxx_0_0 = fft.fft_vcc(fft_size, False, (window.hamming(fft_size)), False, 1)
self.fft_vxx_0 = fft.fft_vcc(fft_size, True, (window.hamming(fft_size)), False, 1)
self.blocks_vector_to_stream_0_0 = blocks.vector_to_stream(gr.sizeof_gr_complex*1, fft_size)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_gr_complex*1, fft_size)
self.blocks_stream_to_vector_0_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, fft_size)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, fft_size)
self.blocks_multiply_const_vxx_1 = blocks.multiply_const_vff((1.0/fft_size, ))
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff((2048.0/fft_size, ))
self.blocks_float_to_complex_0 = blocks.float_to_complex(1)
self.blocks_complex_to_real_0 = blocks.complex_to_real(1)
self.blocks_complex_to_mag_squared_1 = blocks.complex_to_mag_squared(1)
##################################################
# Connections
##################################################
self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_complex_to_mag_squared_1, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.blocks_stream_to_vector_0_0, 0), (self.fft_vxx_0_0, 0))
self.connect((self.fft_vxx_0_0, 0), (self.blocks_vector_to_stream_0_0, 0))
self.connect((self.blocks_vector_to_stream_0_0, 0), (self.blocks_complex_to_real_0, 0))
self.connect((self.blocks_float_to_complex_0, 0), (self.blocks_stream_to_vector_0_0, 0))
self.connect((self.blocks_complex_to_real_0, 0), (self.blocks_multiply_const_vxx_0, 0))
self.connect((self, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.blocks_multiply_const_vxx_0, 0), (self, 0))
self.connect((self.blocks_complex_to_mag_squared_1, 0), (self.blocks_multiply_const_vxx_1, 0))
self.connect((self.blocks_multiply_const_vxx_1, 0), (self.blocks_float_to_complex_0, 0))
def __init__(self, fft_len, sample_rate, average, rate, max_tu,
data_precision):
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.rate = rate
self.max_tu = max_tu - 2 #reserve two bytes for segmentation
self.data_precision = data_precision
if data_precision:
print '32bit FFT in use (more bandwidth and precision)'
else:
print '8bit FFT in use (less bandwidth and precision)'
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, mywindow, True)
self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len)
self.avg = grfilter.single_pole_iir_filter_ff(self.average,
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)
#register message out to other blocks
self.message_port_register_hier_out("pdus")
self._packet_source = packet_source()
#####CONNECTIONS####
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2,
self.avg, self.log, self.sink)
self.msg_connect(self._packet_source, "out", self, "pdus")
####THREADS####
self._main = main_thread(self.msgq, self._packet_source, self.max_tu,
self.fft_len, self.data_precision)
def __init__(self, radioNum):
gr.top_block.__init__(self, "Spectrum Analyzer")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = int(300e3)
self.center_freq = center_freq = 900e6
self.radio_num = radioNum
# Create custom PMT metadata containing the assigned radio number
key0 = pmt.intern("radio_num")
val0 = pmt.from_long(self.radio_num)
extra_meta = pmt.make_dict()
extra_meta = pmt.dict_add(extra_meta, key0, val0)
##################################################
# Blocks
##################################################
self.uhd_usrp_source_0 = uhd.usrp_source(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
args='peak=0.003906',
channels=list(range(0, 1)),
),
)
self.uhd_usrp_source_0.set_center_freq(center_freq, 0)
self.uhd_usrp_source_0.set_gain(28, 0)
self.uhd_usrp_source_0.set_antenna('RX2', 0)
self.uhd_usrp_source_0.set_bandwidth(samp_rate, 0)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
# No synchronization enforced.
self.fft_vxx_0 = fft.fft_vcc(1024, True, window.blackmanharris(1024),
True, 1)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(
gr.sizeof_gr_complex * 1, 1024)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(
gr.sizeof_gr_complex * 1, 1024)
self.blocks_file_meta_sink_0 = blocks.file_meta_sink(
gr.sizeof_gr_complex * 1, f'./sample{self.radio_num}.dat',
samp_rate, 1, blocks.GR_FILE_FLOAT, True, 300000, extra_meta,
False)
self.blocks_file_meta_sink_0.set_unbuffered(False)
##################################################
# Connections
##################################################
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.blocks_vector_to_stream_0, 0),
(self.blocks_file_meta_sink_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.uhd_usrp_source_0, 0),
(self.blocks_stream_to_vector_0, 0))
def test_003(self):
# Same test as above, only use 2 threads
tb = gr.top_block()
fft_size = 32
tmp_data = ((4377+4516j),
(-1706.1268310546875+1638.4256591796875j),
(-915.2083740234375+660.69427490234375j),
(-660.370361328125+381.59600830078125j),
(-499.96044921875+238.41630554199219j),
(-462.26748657226562+152.88948059082031j),
(-377.98440551757812+77.5928955078125j),
(-346.85821533203125+47.152004241943359j),
(-295+20j),
(-286.33609008789062-22.257017135620117j),
(-271.52999877929688-33.081821441650391j),
(-224.6358642578125-67.019538879394531j),
(-244.24473571777344-91.524826049804688j),
(-203.09068298339844-108.54627227783203j),
(-198.45195007324219-115.90768432617188j),
(-182.97744750976562-128.12318420410156j),
(-167-180j),
(-130.33688354492188-173.83778381347656j),
(-141.19784545898438-190.28807067871094j),
(-111.09677124023438-214.48896789550781j),
(-70.039543151855469-242.41630554199219j),
(-68.960540771484375-228.30015563964844j),
(-53.049201965332031-291.47097778320312j),
(-28.695289611816406-317.64553833007812j),
(57-300j),
(45.301143646240234-335.69509887695312j),
(91.936195373535156-373.32437133789062j),
(172.09465026855469-439.275146484375j),
(242.24473571777344-504.47515869140625j),
(387.81732177734375-666.6788330078125j),
(689.48553466796875-918.2142333984375j),
(1646.539306640625-1694.1956787109375j))
src_data = tuple([x/fft_size for x in tmp_data])
expected_result = tuple([complex(primes[2*i], primes[2*i+1]) for i in range(fft_size)])
nthreads = 2
src = blocks.vector_source_c(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, fft_size)
op = fft.fft_vcc(fft_size, False, [], False, nthreads)
v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, fft_size)
dst = blocks.vector_sink_c()
tb.connect(src, s2v, op, v2s, dst)
tb.run()
result_data = dst.data()
self.assert_fft_ok2(expected_result, result_data)
def __init__(self, ipp1="127.0.0.1", ipp2="127.0.0.1", ipp3="127.0.0.1", ipp4="127.0.0.1", iptx="127.0.0.1", samp_rate=100):
gr.top_block.__init__(self, "OFDM Rx")
##################################################
# Parameters
##################################################
self.ipp1 = ipp1
self.ipp2 = ipp2
self.ipp3 = ipp3
self.ipp4 = ipp4
self.iptx = iptx
self.samp_rate = samp_rate
##################################################
# Variables
##################################################
self.pilot_symbols = pilot_symbols = ((1, 1, 1, -1,),)
self.pilot_carriers = pilot_carriers = ((-21, -7, 7, 21,),)
self.payload_mod = payload_mod = digital.constellation_qpsk()
self.packet_length_tag_key = packet_length_tag_key = "packet_len"
self.occupied_carriers = occupied_carriers = (range(-26, -21) + range(-20, -7) + range(-6, 0) + range(1, 7) + range(8, 21) + range(22, 27),)
self.length_tag_key = length_tag_key = "frame_len"
self.header_mod = header_mod = digital.constellation_bpsk()
self.fft_len = fft_len = 64
self.sync_word2 = sync_word2 = [0j, 0j, 0j, 0j, 0j, 0j, (-1+0j), (-1+0j), (-1+0j), (-1+0j), (1+0j), (1+0j), (-1+0j), (-1+0j), (-1+0j), (1+0j), (-1+0j), (1+0j), (1+0j), (1 +0j), (1+0j), (1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j), (1+0j), (-1+0j), (-1+0j), (1+0j), (-1+0j), 0j, (1+0j), (-1+0j), (1+0j), (1+0j), (1+0j), (-1+0j), (1+0j), (1+0j), (1+0j), (-1+0j), (1+0j), (1+0j), (1+0j), (1+0j), (-1+0j), (1+0j), (-1+0j), (-1+0j), (-1+0j), (1+0j), (-1+0j), (1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j), 0j, 0j, 0j, 0j, 0j]
self.sync_word1 = sync_word1 = [0., 0., 0., 0., 0., 0., 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 0., 0., 0., 0., 0.]
self.payload_equalizer = payload_equalizer = digital.ofdm_equalizer_simpledfe(fft_len, payload_mod.base(), occupied_carriers, pilot_carriers, pilot_symbols, 1)
self.packet_len = packet_len = 96
self.header_formatter = header_formatter = digital.packet_header_ofdm(occupied_carriers, n_syms=1, len_tag_key=packet_length_tag_key, frame_len_tag_key=length_tag_key, bits_per_header_sym=header_mod.bits_per_symbol(), bits_per_payload_sym=payload_mod.bits_per_symbol(), scramble_header=False)
self.header_equalizer = header_equalizer = digital.ofdm_equalizer_simpledfe(fft_len, header_mod.base(), occupied_carriers, pilot_carriers, pilot_symbols)
##################################################
# Blocks
##################################################
self.zeromq_pull_source_0_0_0_0_0_0 = zeromq.pull_source(gr.sizeof_gr_complex, 64, "tcp://" + ipp2 + ":55521", 100, True)
self.my_number_sync_timestamp_0 = my.number_sync_timestamp()
self.fft_vxx_1 = fft.fft_vcc(fft_len, True, (), True, 1)
self.digital_ofdm_serializer_vcc_payload = digital.ofdm_serializer_vcc(fft_len, occupied_carriers, length_tag_key, packet_length_tag_key, 1, "", True)
self.digital_ofdm_frame_equalizer_vcvc_1 = digital.ofdm_frame_equalizer_vcvc(payload_equalizer.base(), fft_len/4, length_tag_key, True, 0)
self.digital_crc32_bb_0 = digital.crc32_bb(True, packet_length_tag_key, True)
self.digital_constellation_decoder_cb_1 = digital.constellation_decoder_cb(payload_mod.base())
self.blocks_repack_bits_bb_0 = blocks.repack_bits_bb(payload_mod.bits_per_symbol(), 8, packet_length_tag_key, True, gr.GR_LSB_FIRST)
##################################################
# Connections
##################################################
self.connect((self.blocks_repack_bits_bb_0, 0), (self.digital_crc32_bb_0, 0))
self.connect((self.digital_constellation_decoder_cb_1, 0), (self.blocks_repack_bits_bb_0, 0))
self.connect((self.digital_crc32_bb_0, 0), (self.my_number_sync_timestamp_0, 0))
self.connect((self.digital_ofdm_frame_equalizer_vcvc_1, 0), (self.digital_ofdm_serializer_vcc_payload, 0))
self.connect((self.digital_ofdm_serializer_vcc_payload, 0), (self.digital_constellation_decoder_cb_1, 0))
self.connect((self.fft_vxx_1, 0), (self.digital_ofdm_frame_equalizer_vcvc_1, 0))
self.connect((self.zeromq_pull_source_0_0_0_0_0_0, 0), (self.fft_vxx_1, 0))
def __init__(self, ipp1="127.0.0.1", ipp2="127.0.0.1", ipp3="127.0.0.1", ipp4="127.0.0.1", iptx="127.0.0.1", samp_rate=10000):
gr.top_block.__init__(self, "OFDM Rx")
##################################################
# Parameters
##################################################
self.ipp1 = ipp1
self.ipp2 = ipp2
self.ipp3 = ipp3
self.ipp4 = ipp4
self.iptx = iptx
self.samp_rate = samp_rate
##################################################
# Variables
##################################################
self.pilot_symbols = pilot_symbols = ((1, 1, 1, -1,),)
self.pilot_carriers = pilot_carriers = ((-21, -7, 7, 21,),)
self.payload_mod = payload_mod = digital.constellation_qpsk()
self.packet_length_tag_key = packet_length_tag_key = "packet_len"
self.occupied_carriers = occupied_carriers = (range(-26, -21) + range(-20, -7) + range(-6, 0) + range(1, 7) + range(8, 21) + range(22, 27),)
self.length_tag_key = length_tag_key = "frame_len"
self.header_mod = header_mod = digital.constellation_bpsk()
self.fft_len = fft_len = 64
self.sync_word2 = sync_word2 = [0j, 0j, 0j, 0j, 0j, 0j, (-1+0j), (-1+0j), (-1+0j), (-1+0j), (1+0j), (1+0j), (-1+0j), (-1+0j), (-1+0j), (1+0j), (-1+0j), (1+0j), (1+0j), (1 +0j), (1+0j), (1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j), (1+0j), (-1+0j), (-1+0j), (1+0j), (-1+0j), 0j, (1+0j), (-1+0j), (1+0j), (1+0j), (1+0j), (-1+0j), (1+0j), (1+0j), (1+0j), (-1+0j), (1+0j), (1+0j), (1+0j), (1+0j), (-1+0j), (1+0j), (-1+0j), (-1+0j), (-1+0j), (1+0j), (-1+0j), (1+0j), (-1+0j), (-1+0j), (-1+0j), (-1+0j), 0j, 0j, 0j, 0j, 0j]
self.sync_word1 = sync_word1 = [0., 0., 0., 0., 0., 0., 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 0., 0., 0., 0., 0.]
self.payload_equalizer = payload_equalizer = digital.ofdm_equalizer_simpledfe(fft_len, payload_mod.base(), occupied_carriers, pilot_carriers, pilot_symbols, 1)
self.packet_len = packet_len = 96
self.header_formatter = header_formatter = digital.packet_header_ofdm(occupied_carriers, n_syms=1, len_tag_key=packet_length_tag_key, frame_len_tag_key=length_tag_key, bits_per_header_sym=header_mod.bits_per_symbol(), bits_per_payload_sym=payload_mod.bits_per_symbol(), scramble_header=False)
self.header_equalizer = header_equalizer = digital.ofdm_equalizer_simpledfe(fft_len, header_mod.base(), occupied_carriers, pilot_carriers, pilot_symbols)
##################################################
# Blocks
##################################################
self.zeromq_push_msg_sink_0 = zeromq.push_msg_sink("tcp://" + ipp3 + ":55530", 100)
self.zeromq_pull_source_0_0_0_0_0 = zeromq.pull_source(gr.sizeof_gr_complex, 64, "tcp://"+ ipp2 + ":55520", 100, True)
self.fft_vxx_0 = fft.fft_vcc(fft_len, True, (()), True, 1)
self.digital_packet_headerparser_b_0 = digital.packet_headerparser_b(header_formatter.base())
self.digital_ofdm_serializer_vcc_header = digital.ofdm_serializer_vcc(fft_len, occupied_carriers, length_tag_key, "", 0, "", True)
self.digital_ofdm_frame_equalizer_vcvc_0 = digital.ofdm_frame_equalizer_vcvc(header_equalizer.base(), fft_len/4, length_tag_key, True, 1)
self.digital_ofdm_chanest_vcvc_0 = digital.ofdm_chanest_vcvc((sync_word1), (sync_word2), 1, 0, 3, False)
self.digital_constellation_decoder_cb_0 = digital.constellation_decoder_cb(header_mod.base())
##################################################
# Connections
##################################################
self.msg_connect((self.digital_packet_headerparser_b_0, 'header_data'), (self.zeromq_push_msg_sink_0, 'in'))
self.connect((self.digital_constellation_decoder_cb_0, 0), (self.digital_packet_headerparser_b_0, 0))
self.connect((self.digital_ofdm_chanest_vcvc_0, 0), (self.digital_ofdm_frame_equalizer_vcvc_0, 0))
self.connect((self.digital_ofdm_frame_equalizer_vcvc_0, 0), (self.digital_ofdm_serializer_vcc_header, 0))
self.connect((self.digital_ofdm_serializer_vcc_header, 0), (self.digital_constellation_decoder_cb_0, 0))
self.connect((self.fft_vxx_0, 0), (self.digital_ofdm_chanest_vcvc_0, 0))
self.connect((self.zeromq_pull_source_0_0_0_0_0, 0), (self.fft_vxx_0, 0))
def test_003(self):
# Same test as above, only use 2 threads
tb = gr.top_block()
fft_size = 32
tmp_data = (
(4377 + 4516j), (-1706.1268310546875 + 1638.4256591796875j),
(-915.2083740234375 + 660.69427490234375j),
(-660.370361328125 + 381.59600830078125j), (-499.96044921875 +
238.41630554199219j),
(-462.26748657226562 + 152.88948059082031j), (-377.98440551757812 +
77.5928955078125j),
(-346.85821533203125 + 47.152004241943359j), (-295 + 20j),
(-286.33609008789062 - 22.257017135620117j), (-271.52999877929688 -
33.081821441650391j),
(-224.6358642578125 - 67.019538879394531j), (-244.24473571777344 -
91.524826049804688j),
(-203.09068298339844 - 108.54627227783203j), (-198.45195007324219 -
115.90768432617188j),
(-182.97744750976562 - 128.12318420410156j), (-167 - 180j),
(-130.33688354492188 - 173.83778381347656j), (-141.19784545898438 -
190.28807067871094j),
(-111.09677124023438 - 214.48896789550781j), (-70.039543151855469 -
242.41630554199219j),
(-68.960540771484375 - 228.30015563964844j), (-53.049201965332031 -
291.47097778320312j),
(-28.695289611816406 - 317.64553833007812j), (57 - 300j),
(45.301143646240234 - 335.69509887695312j),
(91.936195373535156 - 373.32437133789062j), (172.09465026855469 -
439.275146484375j),
(242.24473571777344 - 504.47515869140625j), (387.81732177734375 -
666.6788330078125j),
(689.48553466796875 - 918.2142333984375j), (1646.539306640625 -
1694.1956787109375j))
src_data = tuple([x / fft_size for x in tmp_data])
expected_result = tuple([
complex(primes[2 * i], primes[2 * i + 1]) for i in range(fft_size)
])
nthreads = 2
src = blocks.vector_source_c(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, fft_size)
op = fft.fft_vcc(fft_size, False, [], False, nthreads)
v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, fft_size)
dst = blocks.vector_sink_c()
tb.connect(src, s2v, op, v2s, dst)
tb.run()
result_data = dst.data()
self.assert_fft_ok2(expected_result, result_data)
def test_002(self):
src_data = tuple([x / self.fft_size for x in primes_transformed])
expected_result = tuple([complex(primes[2 * i], primes[2 * i + 1]) for i in range(self.fft_size)])
src = blocks.vector_source_c(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
op = fft.fft_vcc(self.fft_size, False, [], False)
v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, self.fft_size)
dst = blocks.vector_sink_c()
self.tb.connect(src, s2v, op, v2s, dst)
self.tb.run()
result_data = dst.data()
self.assert_fft_ok2(expected_result, result_data)
def __init__(self, N=12, M=256, start_index=10, mapping=0, modulation=16, cp_ratio=0.25):
gr.hier_block2.__init__(self,
"scfdma_transmitter_bc",
gr.io_signature(1, 1, gr.sizeof_char*1),
gr.io_signature(1, 1, gr.sizeof_gr_complex*1),
)
##################################################
# Parameters
##################################################
self.N = N
self.M = M
self.start_index = start_index
self.modulation = modulation
self.cp_ratio = cp_ratio
self.mapping = mapping
##################################################
# Blocks
##################################################
self.ofdm_scfdma_subcarrier_mapper_vcvc_0 = ofdm.scfdma_subcarrier_mapper_vcvc(N, M, start_index, mapping)
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc([1.0/(M*N)])
self.ofdm_fbmc_symbol_creation_bvc_0 = ofdm.fbmc_symbol_creation_bvc(N, modulation)
self.ofdm_cyclic_prefixer_0 = ofdm.cyclic_prefixer(M, int(M*(1+cp_ratio)))
self.fft_vxx_0_0 = fft.fft_vcc(M, False, (), True, 1)
self.fft_vxx_0 = fft.fft_vcc(N, True, (), True, 1)
##################################################
# Connections
##################################################
self.connect((self.fft_vxx_0, 0), (self.ofdm_scfdma_subcarrier_mapper_vcvc_0, 0))
self.connect((self.fft_vxx_0_0, 0), (self.ofdm_cyclic_prefixer_0, 0))
self.connect((self.ofdm_cyclic_prefixer_0, 0), (self.blocks_multiply_const_vxx_0,0))
self.connect((self.blocks_multiply_const_vxx_0,0), (self,0))
self.connect((self.ofdm_fbmc_symbol_creation_bvc_0, 0), (self.fft_vxx_0, 0))
self.connect((self.ofdm_scfdma_subcarrier_mapper_vcvc_0, 0), (self.fft_vxx_0_0, 0))
self.connect((self, 0), (self.ofdm_fbmc_symbol_creation_bvc_0, 0))
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Fft To Tcp")
##################################################
# Variables
##################################################
self.veclen = veclen = 8192
self.test = test = 1420e6
self.samp_rate = samp_rate = 1500000
##################################################
# Blocks
##################################################
self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(("localhost", 8080), allow_none=True)
self.xmlrpc_server_0.register_instance(self)
threading.Thread(target=self.xmlrpc_server_0.serve_forever).start()
self.rtlsdr_source_0 = osmosdr.source(args="numchan=" + str(1) + " " + "")
self.rtlsdr_source_0.set_sample_rate(samp_rate)
self.rtlsdr_source_0.set_center_freq(test, 0)
self.rtlsdr_source_0.set_freq_corr(0, 0)
self.rtlsdr_source_0.set_dc_offset_mode(0, 0)
self.rtlsdr_source_0.set_iq_balance_mode(0, 0)
self.rtlsdr_source_0.set_gain_mode(False, 0)
self.rtlsdr_source_0.set_gain(1, 0)
self.rtlsdr_source_0.set_if_gain(20, 0)
self.rtlsdr_source_0.set_bb_gain(20, 0)
self.rtlsdr_source_0.set_antenna("", 0)
self.rtlsdr_source_0.set_bandwidth(0, 0)
self.fft_vxx_0 = fft.fft_vcc(veclen, True, (window.blackmanharris(veclen)), True, 1)
self.blocks_stream_to_vector_1 = blocks.stream_to_vector(gr.sizeof_gr_complex * 1, samp_rate)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex * 1, veclen)
self.blocks_complex_to_mag_0 = blocks.complex_to_mag(veclen)
self.blks2_tcp_sink_0_0 = grc_blks2.tcp_sink(
itemsize=gr.sizeof_gr_complex * samp_rate, addr="127.0.0.1", port=10002, server=True
)
self.blks2_tcp_sink_0 = grc_blks2.tcp_sink(
itemsize=gr.sizeof_float * veclen, addr="127.0.0.1", port=10001, server=True
)
##################################################
# Connections
##################################################
self.connect((self.blocks_complex_to_mag_0, 0), (self.blks2_tcp_sink_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.blocks_stream_to_vector_1, 0), (self.blks2_tcp_sink_0_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_0, 0))
self.connect((self.rtlsdr_source_0, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.rtlsdr_source_0, 0), (self.blocks_stream_to_vector_1, 0))
def test_two(self):
tb = gr.top_block()
MTU = 4000
tagname = "length"
packets = (
(0, 0, 0, 0)*32,
#(0, 0, 1, 0)*16,
#(1, 1, 1, 0)*4,
)
data, tags = ofdm.utils.packets_to_vectors(packets, tagname)
constellation = digital.bpsk_constellation()
src = gr.vector_source_b(data, tags, False, 1)
tag_scaler1 = ofdm.scale_tags(1, tagname, 0.125)
packer = gr.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST)
crc = ofdm.crc32_bb(False, MTU, tagname)
tag_scaler2 = ofdm.scale_tags(1, tagname, 8)
unpacker = gr.packed_to_unpacked_bb(1, gr.GR_MSB_FIRST)
mod1 = digital.chunks_to_symbols_bc(constellation.points())
mod2 = digital.chunks_to_symbols_bc(constellation.points())
occupied_carriers = ((1, 2, 4, 5),)
fft_len = 16
header = ofdm.ofdm_header_bb(len(occupied_carriers[0]))
mux1 = ofdm.tagged_stream_mux(gr.sizeof_gr_complex, 2, tagname, MTU)
mux2 = ofdm.tagged_stream_mux(gr.sizeof_gr_complex*fft_len, 2, tagname, MTU)
ifft = fft.fft_vcc(fft_len, forward=False, window=[1]*fft_len)
cp_len = 4
rolloff_len = 2
cp = digital.ofdm_cyclic_prefixer(fft_len, fft_len+cp_len, rolloff_len, tagname, MTU)
pilot_symbols = ((1j,),)
pilot_carriers = ((3,),)
alloc = ofdm.carrier_allocator_cvc(fft_len,
occupied_carriers,
pilot_carriers,
pilot_symbols,
tagname)
snk = gr.vector_sink_c()
sync_packet = [0, 1, 0, 1, 0, 1] + [0]*10
sync_data, sync_tags = ofdm.utils.packets_to_vectors([sync_packet], tagname, vlen=fft_len)
sync_header = gr.vector_source_c(sync_data, sync_tags, True, fft_len)
tb.connect(src, tag_scaler1, packer, crc, tag_scaler2, unpacker, mod1, (mux1, 1))
tb.connect(crc, header, mod2, (mux1, 0))
tb.connect(mux1, alloc, (mux2, 1))
tb.connect(sync_header, (mux2, 0))
tb.connect(mux2, ifft, cp, snk)
#tb.connect(src, tag_scaler1, packer, crc, tag_scaler2, unpacker, mod1, alloc, snk)
tb.run()
