Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #!/usr/bin/env python
- ##################################################
- # Gnuradio Python Flow Graph
- # Title: Top Block
- # Generated: Thu Aug 23 14:36:34 2012
- ##################################################
- from scipy import *
- from scipy.linalg import toeplitz
- import numpy as np
- import scipy as sp
- import matplotlib as mpl
- import matplotlib.pyplot as plt
- from scipy.signal import lfilter
- from numpy import genfromtxt
- from time import sleep
- import threading
- import time
- import array
- from gnuradio import digital
- from gnuradio import eng_notation
- from gnuradio import filter
- from gnuradio import gr
- from gnuradio.eng_option import eng_option
- from gnuradio.filter import firdes
- from gnuradio.gr import firdes
- #from grc_gnuradio import wxgui as grc_wxgui
- from optparse import OptionParser
- import wx
- #LMS Filter Data
- def process(received):
- preamble = genfromtxt('/home/traviscollins/data/pypreamble.txt', delimiter=',')
- #Correlator
- xcorr=np.correlate(received,preamble)
- max_val=np.max(xcorr)
- locations= np.where(xcorr==max_val)
- index= locations[0][0]
- received_saved=received
- received=received[index:index+len(preamble)]
- #Equalizer
- n=15
- delta=0 #delay
- p = len(received)-delta
- r1=received[n:p]
- r2=received[n::-1]
- R=toeplitz(r1,r2)
- S=preamble[n-delta:p-delta]
- # S=S.conj().transpose()
- f1=np.real(np.linalg.inv(dot(R.conj().transpose(),R)))
- f2=dot(R.conj().transpose(),S)
- f=dot(f1,f2)
- output=sp.signal.lfilter(f,1,received_saved)#filter with filter calculated coeffs
- #Calculate Error
- # error=0
- # error2=0
- # for i in range(0,len(output)):
- # error+=np.abs(np.real(output[i]))-np.abs(np.real(preamble[i]))
- # error2+=np.abs(np.imag(output[i]))-np.abs(np.imag(preamble[i]))
- # print "Error: ",error," | Error2: ",error2
- return output
- class top_block(gr.top_block): #(grc_wxgui.top_block_gui):
- def __init__(self):
- gr.top_block.__init__(self, 'Message Blocks Test')
- ##################################################
- # Variables
- samp_rate=32000
- queue_size=900
- ##################################################
- # Message Queues
- ##################################################
- self.sink_queue = gr.msg_queue(queue_size)
- self.source_queue = gr.msg_queue()
- ##################################################
- # Blocks
- ##################################################
- self.gr_throttle_0 = gr.throttle(gr.sizeof_char*1, samp_rate)
- self.gr_message_source_0 = gr.message_source(gr.sizeof_gr_complex*1, self.source_queue)
- self.gr_message_sink_0 = gr.message_sink(gr.sizeof_gr_complex*1, self.sink_queue, False)
- self.gr_file_source_0 = gr.file_source(gr.sizeof_char*1, "/home/traviscollins/data/input.txt", True)
- self.gr_file_sink_0_0_0 = gr.file_sink(gr.sizeof_gr_complex*1, "/home/traviscollins/data/post.txt")
- self.gr_file_sink_0_0_0.set_unbuffered(False)
- self.gr_file_sink_0_0 = gr.file_sink(gr.sizeof_gr_complex*1, "/home/traviscollins/data/pre.txt")
- self.gr_file_sink_0_0.set_unbuffered(False)
- self.gr_file_sink_0 = gr.file_sink(gr.sizeof_char*1, "/home/traviscollins/data/sig.txt")
- self.gr_file_sink_0.set_unbuffered(False)
- self.digital_dxpsk_mod_0 = digital.dbpsk_mod(
- samples_per_symbol=2,
- excess_bw=0.35,
- gray_coded=False,
- verbose=False,
- log=False)
- self.digital_dxpsk_demod_0 = digital.dbpsk_demod(
- samples_per_symbol=2,
- excess_bw=0.35,
- freq_bw=6.28/100.0,
- phase_bw=6.28/100.0,
- timing_bw=6.28/100.0,
- gray_coded=False,
- verbose=False,
- log=False
- )
- self.channel_model_0 = filter.channel_model(
- noise_voltage=0.0,
- frequency_offset=0.0,
- epsilon=1.0,
- taps=(1.0 + 1.0j, ),
- noise_seed=0,
- )
- #Extras
- self.gr_null = gr.null_sink(gr.sizeof_gr_complex*1)
- self.gr_file_sink_0_0_0_0 = gr.file_sink(gr.sizeof_gr_complex*1, "/home/traviscollins/data/dump.txt")
- self.gr_file_sink_0_0_0_0.set_unbuffered(False)
- ##################################################
- # Worker Threads
- ##################################################
- def _probe_probe():
- while True:
- time.sleep(1.0/(1))
- print "Source: ",self.source_queue.count()
- print "Sink: ",self.sink_queue.count()
- _probe_thread = threading.Thread(target=_probe_probe)
- _probe_thread.daemon = True
- _probe_thread.start()
- ##################################################
- # Connections
- ##################################################
- self.connect((self.gr_file_source_0, 0), (self.gr_throttle_0, 0))
- self.connect((self.digital_dxpsk_mod_0, 0), (self.gr_file_sink_0_0, 0))
- self.connect((self.gr_throttle_0, 0), (self.digital_dxpsk_mod_0, 0))
- self.connect((self.digital_dxpsk_mod_0, 0), (self.channel_model_0, 0))
- self.connect((self.channel_model_0, 0), (self.gr_file_sink_0_0_0, 0))
- self.connect((self.channel_model_0, 0), (self.gr_message_sink_0, 0))
- #self.connect((self.channel_model_0, 0), (self.digital_dxpsk_demod_0, 0))
- self.connect((self.gr_message_source_0, 0), (self.digital_dxpsk_demod_0, 0))
- self.connect((self.gr_message_source_0, 0), (self.gr_file_sink_0_0_0_0, 0))
- self.connect((self.digital_dxpsk_demod_0, 0), (self.gr_file_sink_0, 0))
- def get_samp_rate(self):
- return self.samp_rate
- def set_samp_rate(self, samp_rate):
- self.samp_rate = samp_rate
- #MAIN
- if __name__ == '__main__':
- parser = OptionParser(option_class=eng_option, usage="%prog: [options]")
- (options, args) = parser.parse_args()
- tb = top_block()
- tb.start()
- #Process Data in queues
- while(1):
- if tb.sink_queue.count()>800:
- #Get enough data to be processed
- a_msg=tb.sink_queue.delete_head()
- raw_a=a_msg.to_string()
- for i in range(0,10): #tb.sink_queue.count()):
- a_msg=tb.sink_queue.delete_head()
- raw_a+=a_msg.to_string()
- #Convert message from string to Complex
- a_data = np.fromstring(raw_a, np.complex64, count = int(a_msg.arg2())) # converted amplitude data
- input_a=np.array(a_data)
- #Process Data
- if len(input_a)<400:#message not long enough to contain preamble
- continue
- processed=process(input_a)
- data=processed[0].tostring()
- for i in range(1,len(processed)):
- data+=processed[i].tostring()
- #OLD WAY msg = gr.message_from_string(processed.tostring(),gr.sizeof_gr_complex)
- msg = gr.message_from_string(data,gr.sizeof_gr_complex)
- tb.source_queue.insert_tail(msg)
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement