def run_test(fo, fi, interleaver, Kb, bitspersymbol, K, dimensionality, constellation, N0, seed): tb = gr.top_block() # TX src = blocks.lfsr_32k_source_s() src_head = blocks.head(gr.sizeof_short, Kb / 16) # packet size in shorts s2fsmi = blocks.packed_to_unpacked_ss( bitspersymbol, gr.GR_MSB_FIRST ) # unpack shorts to symbols compatible with the outer FSM input cardinality enc_out = trellis.encoder_ss(fo, 0) # initial state = 0 inter = trellis.permutation(interleaver.K(), interleaver.INTER(), 1, gr.sizeof_short) enc_in = trellis.encoder_ss(fi, 0) # initial state = 0 mod = digital.chunks_to_symbols_sf(constellation, dimensionality) # CHANNEL add = blocks.add_ff() noise = analog.noise_source_f(analog.GR_GAUSSIAN, math.sqrt(N0 / 2), seed) # RX metrics_in = trellis.metrics_f( fi.O(), dimensionality, constellation, digital.TRELLIS_EUCLIDEAN ) # data preprocessing to generate metrics for innner Viterbi va_in = trellis.viterbi_s( fi, K, 0, -1) # Put -1 if the Initial/Final states are not set. deinter = trellis.permutation(interleaver.K(), interleaver.DEINTER(), 1, gr.sizeof_short) metrics_out = trellis.metrics_s( fo.O(), 1, [0, 1, 2, 3], digital.TRELLIS_HARD_SYMBOL ) # data preprocessing to generate metrics for outer Viterbi (hard decisions) va_out = trellis.viterbi_s( fo, K, 0, -1) # Put -1 if the Initial/Final states are not set. 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, enc_out, inter, enc_in, mod) tb.connect(mod, (add, 0)) tb.connect(noise, (add, 1)) tb.connect(add, metrics_in) tb.connect(metrics_in, va_in, deinter, metrics_out, va_out, fsmi2s, dst) tb.run() ntotal = dst.ntotal() nright = dst.nright() runlength = dst.runlength() return (ntotal, ntotal - nright)
def run_test (f,Kb,bitspersymbol,K,dimensionality,tot_constellation,N0,seed): tb = gr.top_block () # TX src = gr.lfsr_32k_source_s() src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the FSM input cardinality enc = trellis.encoder_ss(f,0) # initial state = 0 # essentially here we implement the combination of modulation and channel as a memoryless modulation (the memory induced by the channel is hidden in the FSM) mod = gr.chunks_to_symbols_sf(tot_constellation,dimensionality) # CHANNEL add = gr.add_ff() noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed) # RX metrics = trellis.metrics_f(f.O(),dimensionality,tot_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. fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts dst = gr.check_lfsr_32k_s(); tb.connect (src,src_head,s2fsmi,enc,mod) tb.connect (mod,(add,0)) tb.connect (noise,(add,1)) tb.connect (add,metrics) tb.connect (metrics,va,fsmi2s,dst) tb.run() ntotal = dst.ntotal () nright = dst.nright () runlength = dst.runlength () #print ntotal,nright,runlength return (ntotal,ntotal-nright)
def run_test (f,Kb,bitspersymbol,K,dimensionality,tot_constellation,N0,seed): tb = gr.top_block () # TX src = gr.lfsr_32k_source_s() src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the FSM input cardinality enc = trellis.encoder_ss(f,0) # initial state = 0 # essentially here we implement the combination of modulation and channel as a memoryless modulation (the memory induced by the channel is hidden in the FSM) mod = gr.chunks_to_symbols_sf(tot_constellation,dimensionality) # CHANNEL add = gr.add_ff() noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed) # RX metrics = trellis.metrics_f(f.O(),dimensionality,tot_constellation,trellis.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. fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts dst = gr.check_lfsr_32k_s(); tb.connect (src,src_head,s2fsmi,enc,mod) tb.connect (mod,(add,0)) tb.connect (noise,(add,1)) tb.connect (add,metrics) tb.connect (metrics,va,fsmi2s,dst) tb.run() ntotal = dst.ntotal () nright = dst.nright () runlength = dst.runlength () #print ntotal,nright,runlength return (ntotal,ntotal-nright)
def run_test(f, Kb, bitspersymbol, K, dimensionality, constellation, N0, seed): tb = gr.top_block() # TX # packet = [0]*Kb # for i in range(Kb-1*16): # last 16 bits = 0 to drive the final state to 0 # packet[i] = random.randint(0, 1) # random 0s and 1s # src = gr.vector_source_s(packet,False) src = gr.lfsr_32k_source_s() src_head = gr.head(gr.sizeof_short, Kb / 16) # packet size in shorts # b2s = gr.unpacked_to_packed_ss(1,gr.GR_MSB_FIRST) # pack bits in shorts s2fsmi = gr.packed_to_unpacked_ss( bitspersymbol, gr.GR_MSB_FIRST ) # unpack shorts to symbols compatible with the FSM input cardinality enc = trellis.encoder_ss(f, 0) # initial state = 0 mod = gr.chunks_to_symbols_sf(constellation, dimensionality) # CHANNEL add = gr.add_ff() noise = gr.noise_source_f(gr.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. fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol, gr.GR_MSB_FIRST) # pack FSM input symbols to shorts # s2b = gr.packed_to_unpacked_ss(1,gr.GR_MSB_FIRST) # unpack shorts to bits # dst = gr.vector_sink_s(); dst = gr.check_lfsr_32k_s() tb.connect(src, src_head, s2fsmi, enc, mod) # tb.connect (src,b2s,s2fsmi,enc,mod) tb.connect(mod, (add, 0)) tb.connect(noise, (add, 1)) tb.connect(add, metrics) tb.connect(metrics, va, fsmi2s, dst) # tb.connect (metrics,va,fsmi2s,s2b,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() # ntotal = len(packet) # if len(dst.data()) != ntotal: # print "Error: not enough data\n" # nright = 0; # for i in range(ntotal): # if packet[i]==dst.data()[i]: # nright=nright+1 # else: # print "Error in ", i return (ntotal, ntotal - nright)
def run_test (f,Kb,bitspersymbol,K,dimensionality,constellation,N0,seed): tb = gr.top_block () # TX #packet = [0]*Kb #for i in range(Kb-1*16): # last 16 bits = 0 to drive the final state to 0 #packet[i] = random.randint(0, 1) # random 0s and 1s #src = gr.vector_source_s(packet,False) src = gr.lfsr_32k_source_s() src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts #b2s = gr.unpacked_to_packed_ss(1,gr.GR_MSB_FIRST) # pack bits in shorts s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the FSM input cardinality enc = trellis.encoder_ss(f,0) # initial state = 0 mod = gr.chunks_to_symbols_sf(constellation,dimensionality) # CHANNEL add = gr.add_ff() noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed) # RX metrics = trellis.metrics_f(f.O(),dimensionality,constellation,trellis.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. fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts #s2b = gr.packed_to_unpacked_ss(1,gr.GR_MSB_FIRST) # unpack shorts to bits #dst = gr.vector_sink_s(); dst = gr.check_lfsr_32k_s() tb.connect (src,src_head,s2fsmi,enc,mod) #tb.connect (src,b2s,s2fsmi,enc,mod) tb.connect (mod,(add,0)) tb.connect (noise,(add,1)) tb.connect (add,metrics) tb.connect (metrics,va,fsmi2s,dst) #tb.connect (metrics,va,fsmi2s,s2b,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 () #ntotal = len(packet) #if len(dst.data()) != ntotal: #print "Error: not enough data\n" #nright = 0; #for i in range(ntotal): #if packet[i]==dst.data()[i]: #nright=nright+1 #else: #print "Error in ", i return (ntotal,ntotal-nright)
def run_test(fo, fi, interleaver, Kb, bitspersymbol, K, dimensionality, constellation, N0, seed): tb = gr.top_block() # TX src = gr.lfsr_32k_source_s() src_head = gr.head(gr.sizeof_short, Kb / 16) # packet size in shorts s2fsmi = gr.packed_to_unpacked_ss( bitspersymbol, gr.GR_MSB_FIRST ) # unpack shorts to symbols compatible with the outer FSM input cardinality enc_out = trellis.encoder_ss(fo, 0) # initial state = 0 inter = trellis.permutation(interleaver.K(), interleaver.INTER(), 1, gr.sizeof_short) enc_in = trellis.encoder_ss(fi, 0) # initial state = 0 mod = gr.chunks_to_symbols_sf(constellation, dimensionality) # CHANNEL add = gr.add_ff() noise = gr.noise_source_f(gr.GR_GAUSSIAN, math.sqrt(N0 / 2), seed) # RX metrics_in = trellis.metrics_f( fi.O(), dimensionality, constellation, trellis.TRELLIS_EUCLIDEAN ) # data preprocessing to generate metrics for innner Viterbi va_in = trellis.viterbi_s(fi, K, 0, -1) # Put -1 if the Initial/Final states are not set. deinter = trellis.permutation(interleaver.K(), interleaver.DEINTER(), 1, gr.sizeof_short) metrics_out = trellis.metrics_s( fo.O(), 1, [0, 1, 2, 3], trellis.TRELLIS_HARD_SYMBOL ) # data preprocessing to generate metrics for outer Viterbi (hard decisions) va_out = trellis.viterbi_s(fo, K, 0, -1) # Put -1 if the Initial/Final states are not set. fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol, gr.GR_MSB_FIRST) # pack FSM input symbols to shorts dst = gr.check_lfsr_32k_s() tb.connect(src, src_head, s2fsmi, enc_out, inter, enc_in, mod) tb.connect(mod, (add, 0)) tb.connect(noise, (add, 1)) tb.connect(add, metrics_in) tb.connect(metrics_in, va_in, deinter, metrics_out, va_out, fsmi2s, dst) tb.run() ntotal = dst.ntotal() nright = dst.nright() runlength = dst.runlength() return (ntotal, ntotal - nright)
def run_test(f, Kb, bitspersymbol, K, dimensionality, constellation, N0, seed, P): tb = gr.top_block() # TX src = gr.lfsr_32k_source_s() src_head = gr.head(gr.sizeof_short, Kb / 16 * P) # packet size in shorts s2fsmi = gr.packed_to_unpacked_ss( bitspersymbol, gr.GR_MSB_FIRST ) # unpack shorts to symbols compatible with the FSM input cardinality s2p = gr.stream_to_streams(gr.sizeof_short, P) # serial to parallel enc = trellis.encoder_ss(f, 0) # initiali state = 0 mod = gr.chunks_to_symbols_sf(constellation, dimensionality) # CHANNEL add = [] noise = [] for i in range(P): add.append(gr.add_ff()) noise.append(gr.noise_source_f(gr.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 = gr.streams_to_stream(gr.sizeof_short, P) # parallel to serial fsmi2s = gr.unpacked_to_packed_ss( bitspersymbol, gr.GR_MSB_FIRST) # pack FSM input symbols to shorts dst = gr.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, constellation, f, N0=0.25, seed=-666): """ constellation - a constellation object used for modulation. f - a finite state machine specification used for coding. N0 - noise level seed - random seed """ super(trellis_tb, self).__init__() # packet size in bits (make it multiple of 16 so it can be packed in a # short) packet_size = 1024 * 16 # bits per FSM input symbol # bits per FSM input symbol bitspersymbol = int(round(math.log(f.I()) / math.log(2))) # packet size in trellis steps K = packet_size // bitspersymbol # TX src = blocks.lfsr_32k_source_s() # packet size in shorts src_head = blocks.head(gr.sizeof_short, packet_size // 16) # unpack shorts to symbols compatible with the FSM input cardinality s2fsmi = blocks.packed_to_unpacked_ss(bitspersymbol, gr.GR_MSB_FIRST) # initial FSM state = 0 enc = trellis.encoder_ss(f, 0) mod = digital.chunks_to_symbols_sc(constellation.points(), 1) # CHANNEL add = blocks.add_cc() noise = analog.noise_source_c( analog.GR_GAUSSIAN, math.sqrt( N0 / 2), seed) # RX # data preprocessing to generate metrics for Viterbi metrics = trellis.constellation_metrics_cf( constellation.base(), digital.TRELLIS_EUCLIDEAN) # Put -1 if the Initial/Final states are not set. va = trellis.viterbi_s(f, K, 0, -1) # pack FSM input symbols to shorts fsmi2s = blocks.unpacked_to_packed_ss(bitspersymbol, gr.GR_MSB_FIRST) # check the output self.dst = blocks.check_lfsr_32k_s() self.connect(src, src_head, s2fsmi, enc, mod) self.connect(mod, (add, 0)) self.connect(noise, (add, 1)) self.connect(add, metrics, va, fsmi2s, self.dst)
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 make_rx(tb, fo, fi, dimensionality, tot_constellation, K, interleaver, IT, Es, N0, type): metrics_in = trellis.metrics_f( fi.O(), dimensionality, tot_constellation, digital.TRELLIS_EUCLIDEAN ) # data preprocessing to generate metrics for innner SISO scale = gr.multiply_const_ff(1.0 / N0) gnd = gr.vector_source_f([0], True) inter = [] deinter = [] siso_in = [] siso_out = [] # generate all blocks for it in range(IT): inter.append( trellis.permutation(interleaver.K(), interleaver.INTER(), fi.I(), gr.sizeof_float)) siso_in.append(trellis.siso_f(fi, K, 0, -1, True, False, type)) deinter.append( trellis.permutation(interleaver.K(), interleaver.DEINTER(), fi.I(), gr.sizeof_float)) if it < IT - 1: siso_out.append(trellis.siso_f(fo, K, 0, -1, False, True, type)) else: siso_out.append(trellis.viterbi_s(fo, K, 0, -1)) # no soft outputs needed # connect first stage tb.connect(gnd, inter[0]) tb.connect(metrics_in, scale) tb.connect(scale, (siso_in[0], 1)) # connect the rest for it in range(IT): if it < IT - 1: tb.connect(scale, (siso_in[it + 1], 1)) tb.connect(siso_in[it], deinter[it], (siso_out[it], 1)) tb.connect(gnd, (siso_out[it], 0)) tb.connect(siso_out[it], inter[it + 1]) tb.connect(inter[it], (siso_in[it], 0)) else: tb.connect(siso_in[it], deinter[it], siso_out[it]) tb.connect(inter[it], (siso_in[it], 0)) return (metrics_in, siso_out[IT - 1])
def __init__(self, constellation, f, N0=0.25, seed=-666L): """ constellation - a constellation object used for modulation. f - a finite state machine specification used for coding. N0 - noise level seed - random seed """ super(trellis_tb, self).__init__() # packet size in bits (make it multiple of 16 so it can be packed in a short) packet_size = 1024*16 # bits per FSM input symbol bitspersymbol = int(round(math.log(f.I())/math.log(2))) # bits per FSM input symbol # packet size in trellis steps K = packet_size/bitspersymbol # TX src = blocks.lfsr_32k_source_s() # packet size in shorts src_head = blocks.head(gr.sizeof_short, packet_size/16) # unpack shorts to symbols compatible with the FSM input cardinality s2fsmi = blocks.packed_to_unpacked_ss(bitspersymbol, gr.GR_MSB_FIRST) # initial FSM state = 0 enc = trellis.encoder_ss(f, 0) mod = digital.chunks_to_symbols_sc(constellation.points(), 1) # CHANNEL add = blocks.add_cc() noise = analog.noise_source_c(analog.GR_GAUSSIAN,math.sqrt(N0/2),seed) # RX # data preprocessing to generate metrics for Viterbi metrics = trellis.constellation_metrics_cf(constellation.base(), digital.TRELLIS_EUCLIDEAN) # Put -1 if the Initial/Final states are not set. va = trellis.viterbi_s(f, K, 0, -1) # pack FSM input symbols to shorts fsmi2s = blocks.unpacked_to_packed_ss(bitspersymbol, gr.GR_MSB_FIRST) # check the output self.dst = blocks.check_lfsr_32k_s() self.connect (src, src_head, s2fsmi, enc, mod) self.connect (mod, (add, 0)) self.connect (noise, (add, 1)) self.connect (add, metrics, va, fsmi2s, self.dst)
def run_test(f, Kb, bitspersymbol, K, dimensionality, constellation, N0, seed): tb = gr.top_block() # TX src = blocks.lfsr_32k_source_s() src_head = blocks.head(gr.sizeof_short, Kb / 16) # 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 enc = trellis.encoder_ss(f, 0) # initial state = 0 mod = digital.chunks_to_symbols_sf(constellation, dimensionality) # CHANNEL add = blocks.add_ff() noise = 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. 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, enc, mod) tb.connect(mod, (add, 0)) tb.connect(noise, (add, 1)) tb.connect(add, metrics) tb.connect(metrics, va, 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 make_rx(tb, fo, fi, dimensionality, tot_constellation, K, interleaver, IT, Es, N0, type): metrics_in = trellis.metrics_f( fi.O(), dimensionality, tot_constellation, digital.TRELLIS_EUCLIDEAN ) # data preprocessing to generate metrics for innner SISO scale = blocks.multiply_const_ff(1.0 / N0) gnd = blocks.vector_source_f([0], True) inter = [] deinter = [] siso_in = [] siso_out = [] # generate all blocks for it in range(IT): inter.append(trellis.permutation(interleaver.K(), interleaver.INTER(), fi.I(), gr.sizeof_float)) siso_in.append(trellis.siso_f(fi, K, 0, -1, True, False, type)) deinter.append(trellis.permutation(interleaver.K(), interleaver.DEINTER(), fi.I(), gr.sizeof_float)) if it < IT - 1: siso_out.append(trellis.siso_f(fo, K, 0, -1, False, True, type)) else: siso_out.append(trellis.viterbi_s(fo, K, 0, -1)) # no soft outputs needed # connect first stage tb.connect(gnd, inter[0]) tb.connect(metrics_in, scale) tb.connect(scale, (siso_in[0], 1)) # connect the rest for it in range(IT): if it < IT - 1: tb.connect(metrics_in, (siso_in[it + 1], 1)) tb.connect(siso_in[it], deinter[it], (siso_out[it], 1)) tb.connect(gnd, (siso_out[it], 0)) tb.connect(siso_out[it], inter[it + 1]) tb.connect(inter[it], (siso_in[it], 0)) else: tb.connect(siso_in[it], deinter[it], siso_out[it]) tb.connect(inter[it], (siso_in[it], 0)) return (metrics_in, siso_out[IT - 1])
def run_test (f,Kb,bitspersymbol,K,dimensionality,constellation,N0,seed): tb = gr.top_block () # TX src = gr.lfsr_32k_source_s() src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the FSM input cardinality enc = trellis.encoder_ss(f,0) # initial state = 0 mod = gr.chunks_to_symbols_sf(constellation,dimensionality) # CHANNEL add = gr.add_ff() noise = gr.noise_source_f(gr.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. fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts dst = gr.check_lfsr_32k_s(); tb.connect (src,src_head,s2fsmi,enc,mod) tb.connect (mod,(add,0)) tb.connect (noise,(add,1)) tb.connect (add,metrics) tb.connect (metrics,va,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 make_rx(tb,fo,fi,dimensionality,tot_constellation,K,interleaver,IT,Es,N0,type): scale = gr.multiply_const_ff(math.sqrt(1.0/N0)) gnd = gr.vector_source_f([0],True); inter=[] deinter=[] siso_in=[] siso_out=[] # generate all blocks for it in range(IT): inter.append( trellis.permutation(interleaver.K(),interleaver.INTER(),fi.I(),gr.sizeof_float) ) siso_in.append( trellis.siso_combined_f(fi,K,0,-1,True,False,type,dimensionality,tot_constellation,trellis.TRELLIS_EUCLIDEAN) ) deinter.append( trellis.permutation(interleaver.K(),interleaver.DEINTER(),fi.I(),gr.sizeof_float) ) if it < IT-1: siso_out.append( trellis.siso_f(fo,K,0,-1,False,True,type) ) else: siso_out.append( trellis.viterbi_s(fo,K,0,-1) ) # no soft outputs needed # connect first stage tb.connect (gnd,inter[0]) tb.connect (scale,(siso_in[0],1)) # connect the rest for it in range(IT): if it < IT-1: tb.connect (scale,(siso_in[it+1],1)) tb.connect (siso_in[it],deinter[it],(siso_out[it],1)) tb.connect (gnd,(siso_out[it],0)) tb.connect (siso_out[it],inter[it+1]) tb.connect (inter[it],(siso_in[it],0)) else: tb.connect (siso_in[it],deinter[it],siso_out[it]) tb.connect (inter[it],(siso_in[it],0)) return (scale,siso_out[IT-1])