def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Wav To Raw Iq")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Blocks
##################################################
self.test_wav = blocks.wavfile_source("original.wav", False)
self.rational_resampler_xxx_0 = filter.rational_resampler_fff(
interpolation=2000000,
decimation=44100,
taps=None,
fractional_bw=None,
)
self.blocks_streams_to_stream_0 = blocks.streams_to_stream(gr.sizeof_float*1, 2)
self.blocks_float_to_char_0 = blocks.float_to_char(1, 127)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_char*1, "sample.raw", False)
self.blocks_file_sink_0.set_unbuffered(False)
##################################################
# Connections
##################################################
self.connect((self.test_wav, 1), (self.blocks_streams_to_stream_0, 1))
self.connect((self.blocks_streams_to_stream_0, 0), (self.rational_resampler_xxx_0, 0))
self.connect((self.rational_resampler_xxx_0, 0), (self.blocks_float_to_char_0, 0))
self.connect((self.blocks_float_to_char_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.test_wav, 0), (self.blocks_streams_to_stream_0, 0))
def __init__(self):
gr.hier_block2.__init__(self,
"bch_viterbi_vfvb",
gr.io_signature(1, 1, gr.sizeof_float * 120), # Input signature
gr.io_signature(1, 1, gr.sizeof_char * 40)) # Output signature
# Define blocks and connect them
# Repeat input vector one time to get viterbi decoder state right (tail-biting stuff)
#self.rpt = blocks.repeat(gr.sizeof_float * 120, 2)
# viterbi decoder requires stream as input
#self.vtos = blocks.vector_to_stream(1 * gr.sizeof_float, 120)
# self.vtss = blocks.vector_to_streams(1* gr.sizeof_float, 120, "bch_viterbi_vector_to_streams_0")
self.vtss = blocks.vector_to_streams(1* gr.sizeof_float, 120)
#self.app = blocks.streams_to_stream(1* gr.sizeof_float, 138, "bch_viterbi_streams_to_stream_0")
self.app = blocks.streams_to_stream(1* gr.sizeof_float, 138)
self.connect(self, self.vtss)
for i in range(18):
self.connect( (self.vtss, 120-18+i), (self.app, i) )
for i in range(120):
self.connect( (self.vtss, i), (self.app, i+18) )
# Correct FSM instantiation: k=num_input_bits, n=num_output_bits, Tuple[dim(k*n)] (decimal notation)
self.fsm = trellis.fsm(1, 3, [91, 121, 117])
# Values for viterbi decoder
K = 46 # steps for one coding block
SO = 0 # initial state
SK = -1 # final state (in this case unknown, therefore -1)
D = 3 # dimensionality
# D = 3 follows from the fact that 1 {0,1} input symbol of the encoder produces 3 {0,1} output symbols.
# (packed into one byte {0,1,...,7} )
# with NRZ coding follows:
# 0 --> 1
# 1 --> -1
# This leads to the following constellation input
# | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
constellation = [1, 1, 1, 1, 1, -1, 1, -1, 1, 1, -1, -1, -1, 1, 1, -1, 1, -1, -1, -1, 1, -1, -1, -1]
# print "len(constellation)/D = " + str(len(constellation)/D) + "\tfsm.O = " + str(self.fsm.O())
# Viterbi_combined input: FSM, K, SO, SK, D, TABLE, TYPE
# FSM = Finite State Machine
# K = number of output symbols produced by the FSM
# SO = initial state of the FSM
# SK = final state of the FSM (unknown in this example)
# D = dimensionality
# TABLE = constellation of the input symbols
# self.vit = trellis.viterbi_combined_fb(self.fsm, K, SO, SK, D, constellation, 200, "bch_viterbi_combined_fb_0")
self.vit = trellis.viterbi_combined_fb(self.fsm, K, SO, SK, D, constellation, 200)
self.connect(self.app, self.vit)
# connect all streams which are crated yet
#self.connect(self,self.rpt,self.vtos,self.vit)
# self.keep = blocks.keep_m_in_n(gr.sizeof_char, 40, 46, 6, "bch_viterbi_keep_m_in_n_0")
self.keep = blocks.keep_m_in_n(gr.sizeof_char, 40, 46, 6)
# self.tovec = blocks.stream_to_vector(1, 40, "bch_viterbi_stream_to_vector_0")
self.tovec = blocks.stream_to_vector(1, 40)
self.connect(self.vit, self.keep, self.tovec, self)
def __init__(self):
gr.hier_block2.__init__(
self,
"bch_viterbi_vfvb",
gr.io_signature(1, 1, gr.sizeof_float * 120), # Input signature
gr.io_signature(1, 1, gr.sizeof_char * 40)) # Output signature
# Define blocks and connect them
# Repeat input vector one time to get viterbi decoder state right (tail-biting stuff)
#self.rpt = blocks.repeat(gr.sizeof_float * 120, 2)
# viterbi decoder requires stream as input
#self.vtos = blocks.vector_to_stream(1 * gr.sizeof_float, 120)
self.vtss = blocks.vector_to_streams(1 * gr.sizeof_float, 120)
self.app = blocks.streams_to_stream(1 * gr.sizeof_float, 138)
self.connect(self, self.vtss)
for i in range(18):
self.connect((self.vtss, 120 - 18 + i), (self.app, i))
for i in range(120):
self.connect((self.vtss, i), (self.app, i + 18))
# Correct FSM instantiation: k=num_input_bits, n=num_output_bits, Tuple[dim(k*n)] (decimal notation)
self.fsm = trellis.fsm(1, 3, [91, 121, 117])
# Values for viterbi decoder
K = 46 # steps for one coding block
SO = 0 # initial state
SK = -1 # final state (in this case unknown, therefore -1)
D = 3 # dimensionality
# D = 3 follows from the fact that 1 {0,1} input symbol of the encoder produces 3 {0,1} output symbols.
# (packed into one byte {0,1,...,7} )
# with NRZ coding follows:
# 0 --> 1
# 1 --> -1
# This leads to the following constellation input
# | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
constellation = [
1, 1, 1, 1, 1, -1, 1, -1, 1, 1, -1, -1, -1, 1, 1, -1, 1, -1, -1,
-1, 1, -1, -1, -1
]
# print "len(constellation)/D = " + str(len(constellation)/D) + "\tfsm.O = " + str(self.fsm.O())
# Viterbi_combined input: FSM, K, SO, SK, D, TABLE, TYPE
# FSM = Finite State Machine
# K = number of output symbols produced by the FSM
# SO = initial state of the FSM
# SK = final state of the FSM (unknown in this example)
# D = dimensionality
# TABLE = constellation of the input symbols
self.vit = trellis.viterbi_combined_fb(self.fsm, K, SO, SK, D,
constellation, 200)
self.connect(self.app, self.vit)
# connect all streams which are crated yet
#self.connect(self,self.rpt,self.vtos,self.vit)
self.keep = blocks.keep_m_in_n(gr.sizeof_char, 40, 46, 6)
self.tovec = blocks.stream_to_vector(1, 40)
self.connect(self.vit, self.keep, self.tovec, self)
def __init__(self): gr.hier_block2.__init__(self, "interleaver", gr.io_signature(1, 1, gr.sizeof_char), # Input signature gr.io_signature(1, 1, gr.sizeof_char)) # Output signature self.demux = blocks.stream_to_streams(gr.sizeof_char, INTERLEAVER_I) self.shift_registers = [dvb.fifo_shift_register_bb(INTERLEAVER_M * j) for j in range(INTERLEAVER_I)] self.mux = blocks.streams_to_stream(gr.sizeof_char, INTERLEAVER_I) self.connect(self, self.demux) for j in range(INTERLEAVER_I): self.connect((self.demux, j), self.shift_registers[j], (self.mux, j)) self.connect(self.mux, self)
def run_test (f,Kb,bitspersymbol,K,dimensionality,constellation,N0,seed,P):
tb = gr.top_block ()
# TX
src = blocks.lfsr_32k_source_s()
src_head = blocks.head(gr.sizeof_short,Kb/16*P) # packet size in shorts
s2fsmi=blocks.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the FSM input cardinality
s2p = blocks.stream_to_streams(gr.sizeof_short,P) # serial to parallel
enc = trellis.encoder_ss(f,0) # initiali state = 0
mod = digital.chunks_to_symbols_sf(constellation,dimensionality)
# CHANNEL
add=[]
noise=[]
for i in range(P):
add.append(blocks.add_ff())
noise.append(analog.noise_source_f(analog.GR_GAUSSIAN,math.sqrt(N0/2),seed))
# RX
metrics = trellis.metrics_f(f.O(),dimensionality,constellation,digital.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for Viterbi
va = trellis.viterbi_s(f,K,0,-1) # Put -1 if the Initial/Final states are not set.
p2s = blocks.streams_to_stream(gr.sizeof_short,P) # parallel to serial
fsmi2s=blocks.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts
dst = blocks.check_lfsr_32k_s()
tb.connect (src,src_head,s2fsmi,s2p)
for i in range(P):
tb.connect ((s2p,i),(enc,i),(mod,i))
tb.connect ((mod,i),(add[i],0))
tb.connect (noise[i],(add[i],1))
tb.connect (add[i],(metrics,i))
tb.connect ((metrics,i),(va,i),(p2s,i))
tb.connect (p2s,fsmi2s,dst)
tb.run()
# A bit of cheating: run the program once and print the
# final encoder state.
# Then put it as the last argument in the viterbi block
#print "final state = " , enc.ST()
ntotal = dst.ntotal ()
nright = dst.nright ()
runlength = dst.runlength ()
return (ntotal,ntotal-nright)
def __init__(self): gr.hier_block2.__init__(self, "deinterleaver", gr.io_signature(1, 1, gr.sizeof_char), # Input signature gr.io_signature(1, 1, gr.sizeof_char)) # Output signature self.demux = blocks.stream_to_streams(gr.sizeof_char, INTERLEAVER_I) self.shift_registers = [dvb.fifo_shift_register_bb(INTERLEAVER_M * j) for j in range(INTERLEAVER_I)] # Deinterleaver shift registers are reversed compared to interleaver self.shift_registers.reverse() self.mux = blocks.streams_to_stream(gr.sizeof_char, INTERLEAVER_I) # Remove the uninitialised zeros that come out of the deinterleaver self.skip = blocks.skiphead(gr.sizeof_char, DELAY) self.connect(self, self.demux) for j in range(INTERLEAVER_I): self.connect((self.demux, j), self.shift_registers[j], (self.mux, j)) self.connect(self.mux, self.skip, self)
def __init__(self, sequence1, sequence2, samp_rate, center_freq):
"""
Description:
This block is functionally equivalent to a conventional frequency xlating FIR filter, with filter taps given by the kronecker product of sequence1 with sequence2.
This block consists of two filtering steps. First, the received samples are filtered using a frequency xlating filter with frequency offset equal to center_freq and taps equal to sequence2. Second, the output is fed into a S/P converter to generate len(sequence2) parallel substreams, and each substream is filtered with identical filter with taps equal to sequence1. Then all substreams are connected to a P/S converter to generate the output sequence.
Complexity discussion:
Originally the filter taps have length len(sequence1)*len(sequence2).
For the kronecker we have one filter of len(sequence2), followed by a bank of len(sequence2) filters, each of length len(sequence1) operating at a rate 1/len(sequence2), for a total complexity of roughly len(sequence2)+len(sequence1), thus resulting in considerable complexity reduction.
Args:
sequence1: the identical taps of each parallel filter in the filter bank.
sequence2: the taps of the first filter.
samp_rate: the samp_rate of the first freq_xlating_fir filter.
center_freq: the center frequency of the freq_xlating_fir filter.
"""
gr.hier_block2.__init__(
self,
"kronecker_filter",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
self.n = n = len(sequence2)
# Build filterbank
self._s2ss = blocks.stream_to_streams(gr.sizeof_gr_complex, n)
self._ss2s = blocks.streams_to_stream(gr.sizeof_gr_complex, n)
self._filter2 = filter.freq_xlating_fir_filter_ccc(
1, sequence2, center_freq, samp_rate)
self._filter = [0] * n
for i in range(n):
self._filter[i] = filter.interp_fir_filter_ccc(1, sequence1)
# Connect blocks
self.connect(self, self._filter2)
self.connect(self._filter2, self._s2ss)
for i in range(n):
self.connect((self._s2ss, i), self._filter[i])
self.connect(self._filter[i], (self._ss2s, i))
self.connect(self._ss2s, self)
def test_002(self):
# Test streams_to_stream (using stream_to_streams).
n = 8
src_len = n * 8
src_data = tuple(range(src_len))
expected_results = src_data
src = blocks.vector_source_i(src_data)
op1 = blocks.stream_to_streams(gr.sizeof_int, n)
op2 = blocks.streams_to_stream(gr.sizeof_int, n)
dst = blocks.vector_sink_i()
self.tb.connect(src, op1)
for i in range(n):
self.tb.connect((op1, i), (op2, i))
self.tb.connect(op2, dst)
self.tb.run()
self.assertEqual(expected_results, dst.data())
def test_002(self):
# Test streams_to_stream (using stream_to_streams).
n = 8
src_len = n * 8
src_data = tuple(range(src_len))
expected_results = src_data
src = blocks.vector_source_i(src_data)
op1 = blocks.stream_to_streams(gr.sizeof_int, n)
op2 = blocks.streams_to_stream(gr.sizeof_int, n)
dst = blocks.vector_sink_i()
self.tb.connect(src, op1)
for i in range(n):
self.tb.connect((op1, i), (op2, i))
self.tb.connect(op2, dst)
self.tb.run()
self.assertEqual(expected_results, dst.data())
def __init__(self, sequence1, sequence2, samp_rate, center_freq):
"""
Description:
This block is functionally equivalent to a conventional frequency xlating FIR filter, with filter taps given by the kronecker product of sequence1 with sequence2.
This block consists of two filtering steps. First, the received samples are filtered using a frequency xlating filter with frequency offset equal to center_freq and taps equal to sequence2. Second, the output is fed into a S/P converter to generate len(sequence2) parallel substreams, and each substream is filtered with identical filter with taps equal to sequence1. Then all substreams are connected to a P/S converter to generate the output sequence.
Complexity discussion:
Originally the filter taps have length len(sequence1)*len(sequence2).
For the kronecker we have one filter of len(sequence2), followed by a bank of len(sequence2) filters, each of length len(sequence1) operating at a rate 1/len(sequence2), for a total complexity of roughly len(sequence2)+len(sequence1), thus resulting in considerable complexity reduction.
Args:
sequence1: the identical taps of each parallel filter in the filter bank.
sequence2: the taps of the first filter.
samp_rate: the samp_rate of the first freq_xlating_fir filter.
center_freq: the center frequency of the freq_xlating_fir filter.
"""
gr.hier_block2.__init__(self,
"kronecker_filter",
gr.io_signature(1,1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1,1, gr.sizeof_gr_complex)) # Output signature
self.n = n = len(sequence2)
# Build filterbank
self._s2ss = blocks.stream_to_streams(gr.sizeof_gr_complex,n)
self._ss2s = blocks.streams_to_stream(gr.sizeof_gr_complex,n)
self._filter2=filter.freq_xlating_fir_filter_ccc(1,sequence2,center_freq,samp_rate)
self._filter=[0]*n
for i in range(n):
self._filter[i]=filter.interp_fir_filter_ccc(1,sequence1)
# Connect blocks
self.connect(self, self._filter2)
self.connect(self._filter2, self._s2ss)
for i in range(n):
self.connect((self._s2ss, i),self._filter[i])
self.connect(self._filter[i],(self._ss2s, i))
self.connect(self._ss2s,self)
def __init__(self, mpoints, taps=None):
"""
Takes M complex streams in, produces single complex stream out
that runs at M times the input sample rate
Args:
mpoints: number of freq bins/interpolation factor/subbands
taps: filter taps for subband filter
The channel spacing is equal to the input sample rate.
The total bandwidth and output sample rate are equal the input
sample rate * nchannels.
Output stream to frequency mapping:
channel zero is at zero frequency.
if mpoints is odd:
Channels with increasing positive frequencies come from
channels 1 through (N-1)/2.
Channel (N+1)/2 is the maximum negative frequency, and
frequency increases through N-1 which is one channel lower
than the zero frequency.
if mpoints is even:
Channels with increasing positive frequencies come from
channels 1 through (N/2)-1.
Channel (N/2) is evenly split between the max positive and
negative bins.
Channel (N/2)+1 is the maximum negative frequency, and
frequency increases through N-1 which is one channel lower
than the zero frequency.
Channels near the frequency extremes end up getting cut
off by subsequent filters and therefore have diminished
utility.
"""
item_size = gr.sizeof_gr_complex
gr.hier_block2.__init__(self, "synthesis_filterbank",
gr.io_signature(mpoints, mpoints, item_size), # Input signature
gr.io_signature(1, 1, item_size)) # Output signature
if taps is None:
taps = _generate_synthesis_taps(mpoints)
# pad taps to multiple of mpoints
r = len(taps) % mpoints
if r != 0:
taps = taps + (mpoints - r) * (0,)
# split in mpoints separate set of taps
sub_taps = _split_taps(taps, mpoints)
self.ss2v = blocks.streams_to_vector(item_size, mpoints)
self.ifft = fft.fft_vcc(mpoints, False, [])
self.v2ss = blocks.vector_to_streams(item_size, mpoints)
# mpoints filters go in here...
self.ss2s = blocks.streams_to_stream(item_size, mpoints)
for i in range(mpoints):
self.connect((self, i), (self.ss2v, i))
self.connect(self.ss2v, self.ifft, self.v2ss)
# build mpoints fir filters...
for i in range(mpoints):
f = fft_filter_ccc(1, sub_taps[i])
self.connect((self.v2ss, i), f)
self.connect(f, (self.ss2s, i))
self.connect(self.ss2s, self)
def run_test(seed,blocksize):
tb = gr.top_block()
##################################################
# Variables
##################################################
M = 2
K = 1
P = 2
h = (1.0*K)/P
L = 3
Q = 4
frac = 0.99
f = trellis.fsm(P,M,L)
# CPFSK signals
#p = numpy.ones(Q)/(2.0)
#q = numpy.cumsum(p)/(1.0*Q)
# GMSK signals
BT=0.3;
tt=numpy.arange(0,L*Q)/(1.0*Q)-L/2.0;
#print tt
p=(0.5*scipy.special.erfc(2*math.pi*BT*(tt-0.5)/math.sqrt(math.log(2.0))/math.sqrt(2.0))-0.5*scipy.special.erfc(2*math.pi*BT*(tt+0.5)/math.sqrt(math.log(2.0))/math.sqrt(2.0)))/2.0;
p=p/sum(p)*Q/2.0;
#print p
q=numpy.cumsum(p)/Q;
q=q/q[-1]/2.0;
#print q
(f0T,SS,S,F,Sf,Ff,N) = fsm_utils.make_cpm_signals(K,P,M,L,q,frac)
#print N
#print Ff
Ffa = numpy.insert(Ff,Q,numpy.zeros(N),axis=0)
#print Ffa
MF = numpy.fliplr(numpy.transpose(Ffa))
#print MF
E = numpy.sum(numpy.abs(Sf)**2,axis=0)
Es = numpy.sum(E)/f.O()
#print Es
constellation = numpy.reshape(numpy.transpose(Sf),N*f.O())
#print Ff
#print Sf
#print constellation
#print numpy.max(numpy.abs(SS - numpy.dot(Ff , Sf)))
EsN0_db = 10.0
N0 = Es * 10.0**(-(1.0*EsN0_db)/10.0)
#N0 = 0.0
#print N0
head = 4
tail = 4
numpy.random.seed(seed*666)
data = numpy.random.randint(0, M, head+blocksize+tail+1)
#data = numpy.zeros(blocksize+1+head+tail,'int')
for i in range(head):
data[i]=0
for i in range(tail+1):
data[-i]=0
##################################################
# Blocks
##################################################
random_source_x_0 = blocks.vector_source_b(data.tolist(), False)
digital_chunks_to_symbols_xx_0 = digital.chunks_to_symbols_bf((-1, 1), 1)
filter_interp_fir_filter_xxx_0 = filter.interp_fir_filter_fff(Q, p)
analog_frequency_modulator_fc_0 = analog.frequency_modulator_fc(2*math.pi*h*(1.0/Q))
blocks_add_vxx_0 = blocks.add_vcc(1)
analog_noise_source_x_0 = analog.noise_source_c(analog.GR_GAUSSIAN, (N0/2.0)**0.5, -long(seed))
blocks_multiply_vxx_0 = blocks.multiply_vcc(1)
analog_sig_source_x_0 = analog.sig_source_c(Q, analog.GR_COS_WAVE, -f0T, 1, 0)
# only works for N=2, do it manually for N>2...
filter_fir_filter_xxx_0_0 = filter.fir_filter_ccc(Q, MF[0].conjugate())
filter_fir_filter_xxx_0_0_0 = filter.fir_filter_ccc(Q, MF[1].conjugate())
blocks_streams_to_stream_0 = blocks.streams_to_stream(gr.sizeof_gr_complex*1, int(N))
blocks_skiphead_0 = blocks.skiphead(gr.sizeof_gr_complex*1, int(N*(1+0)))
viterbi = trellis.viterbi_combined_cb(f, head+blocksize+tail, 0, -1, int(N),
constellation, digital.TRELLIS_EUCLIDEAN)
blocks_vector_sink_x_0 = blocks.vector_sink_b()
##################################################
# Connections
##################################################
tb.connect((random_source_x_0, 0), (digital_chunks_to_symbols_xx_0, 0))
tb.connect((digital_chunks_to_symbols_xx_0, 0), (filter_interp_fir_filter_xxx_0, 0))
tb.connect((filter_interp_fir_filter_xxx_0, 0), (analog_frequency_modulator_fc_0, 0))
tb.connect((analog_frequency_modulator_fc_0, 0), (blocks_add_vxx_0, 0))
tb.connect((analog_noise_source_x_0, 0), (blocks_add_vxx_0, 1))
tb.connect((blocks_add_vxx_0, 0), (blocks_multiply_vxx_0, 0))
tb.connect((analog_sig_source_x_0, 0), (blocks_multiply_vxx_0, 1))
tb.connect((blocks_multiply_vxx_0, 0), (filter_fir_filter_xxx_0_0, 0))
tb.connect((blocks_multiply_vxx_0, 0), (filter_fir_filter_xxx_0_0_0, 0))
tb.connect((filter_fir_filter_xxx_0_0, 0), (blocks_streams_to_stream_0, 0))
tb.connect((filter_fir_filter_xxx_0_0_0, 0), (blocks_streams_to_stream_0, 1))
tb.connect((blocks_streams_to_stream_0, 0), (blocks_skiphead_0, 0))
tb.connect((blocks_skiphead_0, 0), (viterbi, 0))
tb.connect((viterbi, 0), (blocks_vector_sink_x_0, 0))
tb.run()
dataest = blocks_vector_sink_x_0.data()
#print data
#print numpy.array(dataest)
perr = 0
err = 0
for i in range(blocksize):
if data[head+i] != dataest[head+i]:
#print i
err += 1
if err != 0 :
perr = 1
return (err,perr)
def __init__(self, baud=20000, deviation=25000, frequency_shift=0, read_file='', write_file='', interpolate=1):
gr.top_block.__init__(self, "Tpms Fsk")
##################################################
# Parameters
##################################################
self.baud = baud
self.deviation = deviation
self.frequency_shift = frequency_shift
self.read_file = read_file
self.write_file = write_file
self.interpolate = interpolate
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 2.5e5
self.sensivity = sensivity = deviation/(samp_rate*0.16)
self.samp_per_symbol = samp_per_symbol = samp_rate/baud
##################################################
# Blocks
##################################################
self.rational_resampler_xxx_0 = filter.rational_resampler_ccc(
interpolation=interpolate,
decimation=1,
taps=None,
fractional_bw=None,
)
self.freq_xlating_fir_filter_xxx_0 = filter.freq_xlating_fir_filter_ccc(1, (1, ), frequency_shift, samp_rate)
self.blocks_uchar_to_float_0 = blocks.uchar_to_float()
self.blocks_streams_to_stream_0 = blocks.streams_to_stream(gr.sizeof_char*1, 2)
self.blocks_repeat_0 = blocks.repeat(gr.sizeof_float*1, int(samp_per_symbol))
self.blocks_multiply_const_vxx_1_0 = blocks.multiply_const_vff((127, ))
self.blocks_multiply_const_vxx_1 = blocks.multiply_const_vff((127, ))
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff((1.0/127, ))
self.blocks_float_to_uchar_0_0 = blocks.float_to_uchar()
self.blocks_float_to_uchar_0 = blocks.float_to_uchar()
self.blocks_file_source_0 = blocks.file_source(gr.sizeof_char*1, read_file, False)
self.blocks_file_source_0.set_begin_tag(pmt.PMT_NIL)
self.blocks_file_sink_0_0 = blocks.file_sink(gr.sizeof_char*1, write_file, False)
self.blocks_file_sink_0_0.set_unbuffered(False)
self.blocks_complex_to_float_0 = blocks.complex_to_float(1)
self.blocks_add_const_vxx_1_0 = blocks.add_const_vff((1, ))
self.blocks_add_const_vxx_1 = blocks.add_const_vff((1, ))
self.blocks_add_const_vxx_0 = blocks.add_const_vff((-1, ))
self.analog_frequency_modulator_fc_0 = analog.frequency_modulator_fc(sensivity)
##################################################
# Connections
##################################################
self.connect((self.analog_frequency_modulator_fc_0, 0), (self.freq_xlating_fir_filter_xxx_0, 0))
self.connect((self.blocks_add_const_vxx_0, 0), (self.blocks_repeat_0, 0))
self.connect((self.blocks_add_const_vxx_1, 0), (self.blocks_multiply_const_vxx_1, 0))
self.connect((self.blocks_add_const_vxx_1_0, 0), (self.blocks_multiply_const_vxx_1_0, 0))
self.connect((self.blocks_complex_to_float_0, 0), (self.blocks_add_const_vxx_1, 0))
self.connect((self.blocks_complex_to_float_0, 1), (self.blocks_add_const_vxx_1_0, 0))
self.connect((self.blocks_file_source_0, 0), (self.blocks_uchar_to_float_0, 0))
self.connect((self.blocks_float_to_uchar_0, 0), (self.blocks_streams_to_stream_0, 0))
self.connect((self.blocks_float_to_uchar_0_0, 0), (self.blocks_streams_to_stream_0, 1))
self.connect((self.blocks_multiply_const_vxx_0, 0), (self.blocks_add_const_vxx_0, 0))
self.connect((self.blocks_multiply_const_vxx_1, 0), (self.blocks_float_to_uchar_0, 0))
self.connect((self.blocks_multiply_const_vxx_1_0, 0), (self.blocks_float_to_uchar_0_0, 0))
self.connect((self.blocks_repeat_0, 0), (self.analog_frequency_modulator_fc_0, 0))
self.connect((self.blocks_streams_to_stream_0, 0), (self.blocks_file_sink_0_0, 0))
self.connect((self.blocks_uchar_to_float_0, 0), (self.blocks_multiply_const_vxx_0, 0))
self.connect((self.freq_xlating_fir_filter_xxx_0, 0), (self.rational_resampler_xxx_0, 0))
self.connect((self.rational_resampler_xxx_0, 0), (self.blocks_complex_to_float_0, 0))
def __init__(self, mpoints, taps=None):
"""
Takes M complex streams in, produces single complex stream out
that runs at M times the input sample rate
Args:
mpoints: number of freq bins/interpolation factor/subbands
taps: filter taps for subband filter
The channel spacing is equal to the input sample rate.
The total bandwidth and output sample rate are equal the input
sample rate * nchannels.
Output stream to frequency mapping:
channel zero is at zero frequency.
if mpoints is odd:
Channels with increasing positive frequencies come from
channels 1 through (N-1)/2.
Channel (N+1)/2 is the maximum negative frequency, and
frequency increases through N-1 which is one channel lower
than the zero frequency.
if mpoints is even:
Channels with increasing positive frequencies come from
channels 1 through (N/2)-1.
Channel (N/2) is evenly split between the max positive and
negative bins.
Channel (N/2)+1 is the maximum negative frequency, and
frequency increases through N-1 which is one channel lower
than the zero frequency.
Channels near the frequency extremes end up getting cut
off by subsequent filters and therefore have diminished
utility.
"""
item_size = gr.sizeof_gr_complex
gr.hier_block2.__init__(self, "synthesis_filterbank",
gr.io_signature(mpoints, mpoints, item_size), # Input signature
gr.io_signature(1, 1, item_size)) # Output signature
if taps is None:
taps = _generate_synthesis_taps(mpoints)
# pad taps to multiple of mpoints
r = len(taps) % mpoints
if r != 0:
taps = taps + (mpoints - r) * (0,)
# split in mpoints separate set of taps
sub_taps = _split_taps(taps, mpoints)
self.ss2v = blocks.streams_to_vector(item_size, mpoints)
self.ifft = fft.fft_vcc(mpoints, False, [])
self.v2ss = blocks.vector_to_streams(item_size, mpoints)
# mpoints filters go in here...
self.ss2s = blocks.streams_to_stream(item_size, mpoints)
for i in range(mpoints):
self.connect((self, i), (self.ss2v, i))
self.connect(self.ss2v, self.ifft, self.v2ss)
# build mpoints fir filters...
for i in range(mpoints):
f = fft_filter_ccc(1, sub_taps[i])
self.connect((self.v2ss, i), f)
self.connect(f, (self.ss2s, i))
self.connect(self.ss2s, self)
def __init__(self,options):
'''
Constructor for top block of Power Estimator
Creates the graph for calculating mean and variance
'''
gr.hier_block2.__init__(self, "periodogram", \
gr.io_signature(1,1,gr.sizeof_gr_complex), \
gr.io_signature(0,0,0) )
scalarx=blocks.multiply_const_cc(1)
########## Node 1 - streams2vector block (input from usrp & output to fft block) ##########
s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, options.fft_size)
#Node 3 - fft block
mywindow = filter.window.blackmanharris(options.fft_size)
ffter = fft.fft_vcc(options.fft_size, True, mywindow)
#Node 4 - magnitude-squared block
c2mag = blocks.complex_to_mag_squared(options.fft_size)
#Node 5 - vector2stream block
vector2stream = blocks.vector_to_stream(gr.sizeof_float,options.fft_size)
#Node 6 - stream2streams block
stream2streams = blocks.stream_to_streams(gr.sizeof_float, options.fft_size)
#Node 7 - adder block
self.sumofNstreams = blocks.add_ff()
#Node 8 - multiplier block (used to divide the output of adder block)
self.avgofNstreams = blocks.multiply_const_ff(1.0/options.noofbins) # TODO: will depend on the number of bins
#Node 9 - sinks (vector and null)
to_nullsink = blocks.streams_to_stream(gr.sizeof_float,10)
#self.vsink = gr.vector_sink_f()
self.fsink = blocks.file_sink(gr.sizeof_float,"fsink.dat")
if options.fft_size != options.noofbins:
streams2stream = blocks.streams_to_stream(gr.sizeof_float, options.fft_size-options.noofbins)
nullsink = blocks.null_sink(gr.sizeof_float)
#Connect Phase 1 - From USRP source to stream2streams
self.connect(self, scalarx, s2v, ffter, c2mag, vector2stream,stream2streams)
for index in range(options.noofbins):
self.connect((stream2streams,index), (self.sumofNstreams, index))
i=10
#Connect Phase 2 - From stream2streams to adder(few) and streams2stream(remaining)
'''for index in range(5):
self.connect((stream2streams,index), (to_nullsink,index))
for index in range(5,options.noofbins-5):
self.connect((stream2streams,index), (sumofNstreams, index-5))
for index in range(options.fft_size-5,options.fft_size):
self.connect((stream2streams,index), (to_nullsink,i))
i=i+1
else:
for index in range(5,options.noofbins+5):
self.connect((stream2streams,index), (sumofNstreams, index-5))
for index in range(options.noofbins+5,options.fft_size):
self.connect((stream2streams,index), (streams2stream,index-options.noofbins))'''
#Connect Phase 3 - (few) from adder to vector sink, (remaining) to null sink
#self.connect(streams2stream, nullsink)
self.connect(self.sumofNstreams,self.avgofNstreams,self.fsink)
#self.connect(to_nullsink,nullsink)
print "FFT size %d" % (options.fft_size)
print "Nblocks considered %d" % (options.nblocks)
print "No.of bins considered %d" % (options.noofbins)
