#!/usr/bin/env python
##################################################
# Gnuradio Python Flow Graph
# Title: Gsm Receiver Usrp Channelizer Python
# Generated: Sun Feb  9 12:46:36 2014
##################################################

from gnuradio import blocks
from gnuradio import eng_notation
from gnuradio import gr
from gnuradio import uhd
from gnuradio.eng_option import eng_option
from gnuradio.filter import firdes
from gnuradio.filter import pfb
from optparse import OptionParser
import gsm
import time
from numpy import fft


class gsm_receiver_usrp_channelizer_python(gr.top_block):

    def __init__(self, length=0.2, gain=25, channelizer_osr=1, fc=937e6, usrp_decim=4, fs=100e6):
        gr.top_block.__init__(self, "Gsm Receiver Usrp Channelizer Python")

        ##################################################
        # Parameters
        ##################################################
        self.length = length
        self.gain = gain
        self.channelizer_osr = channelizer_osr
        self.fc = fc
        self.usrp_decim = usrp_decim
        self.channels_num = int(round(fs/usrp_decim/200e3))
        self.fs = fs

        ##################################################
        # Variables
        ##################################################
        self.samp_rate = 100e6/self.usrp_decim
        self.samp_rate_channelizer_out = self.samp_rate/self.channels_num*channelizer_osr
        self.freqs = fft.fftfreq(self.channels_num,1/self.samp_rate)+self.fc
        self.arfcns = get_arfcns_from_freqs(self.freqs,"e")
        print self.freqs
        print self.arfcns

        ##################################################
        # Blocks
        ##################################################
        self.uhd_usrp_source_0 = uhd.usrp_source(
        	device_addr="addr=192.168.11.2",
        	stream_args=uhd.stream_args(
        		cpu_format="fc32",
        		otw_format="sc16",
        		channels=range(1),
        	),
        )
        self.uhd_usrp_source_0.set_samp_rate(self.samp_rate)
        self.uhd_usrp_source_0.set_center_freq(fc, 0)
        self.uhd_usrp_source_0.set_gain(gain, 0)
        self.pfb_channelizer_ccf_0 = pfb.channelizer_ccf(
        	  self.channels_num,
        	  (),
        	  channelizer_osr,
        	  100)
        self.pfb_channelizer_ccf_0.set_channel_map(([]))

        self.blocks_head_0 = blocks.head(gr.sizeof_gr_complex*1, int(self.samp_rate*length))
        self.gsm_bursts_printer_0 = gsm.bursts_printer()
        
        self.connect((self.uhd_usrp_source_0, 0), (self.blocks_head_0, 0))
        self.connect((self.blocks_head_0, 0), (self.pfb_channelizer_ccf_0, 0))

        self.gsm_receiver_hier = {}        

        for ii in xrange(0,self.channels_num):
            self.gsm_receiver_hier[ii] = gsm.receiver_hier(self.samp_rate_channelizer_out, 4, int(self.freqs[ii]/1e5))
            self.connect((self.pfb_channelizer_ccf_0, ii), (self.gsm_receiver_hier[ii], 0))
            self.msg_connect(self.gsm_receiver_hier[ii], "bursts", self.gsm_bursts_printer_0, "bursts")
        

# QT sink close method reimplementation

    def get_length(self):
        return self.length

    def set_length(self, length):
        self.length = length

    def get_gain(self):
        return self.gain

    def set_gain(self, gain):
        self.gain = gain
        self.uhd_usrp_source_0.set_gain(self.gain, 0)

    def get_channelizer_osr(self):
        return self.channelizer_osr

    def set_channelizer_osr(self, channelizer_osr):
        self.channelizer_osr = channelizer_osr
        self.set_samp_rate_channelizer_out(self.samp_rate/self.channels_num*self.channelizer_osr)

    def get_fc(self):
        return self.fc

    def set_fc(self, fc):
        self.fc = fc
        self.uhd_usrp_source_0.set_center_freq(self.fc, 0)

    def get_usrp_decim(self):
        return self.usrp_decim

    def set_usrp_decim(self, usrp_decim):
        self.usrp_decim = usrp_decim
        self.set_samp_rate(100e6/self.usrp_decim)

    def get_channels_num(self):
        return self.channels_num

    def set_channels_num(self, channels_num):
        self.channels_num = channels_num
        self.set_samp_rate_channelizer_out(self.samp_rate/self.channels_num*self.channelizer_osr)

    def get_fs(self):
        return self.fs

    def set_fs(self, fs):
        self.fs = fs

    def get_samp_rate(self):
        return self.samp_rate

    def set_samp_rate(self, samp_rate):
        self.samp_rate = samp_rate
        self.set_samp_rate_channelizer_out(self.samp_rate/self.channels_num*self.channelizer_osr)
        self.uhd_usrp_source_0.set_samp_rate(self.samp_rate)

    def get_samp_rate_channelizer_out(self):
        return self.samp_rate_channelizer_out

    def set_samp_rate_channelizer_out(self, samp_rate_channelizer_out):
        self.samp_rate_channelizer_out = samp_rate_channelizer_out

def get_arfcns_from_freqs(freqs,region):
    arfcns = {}
    for ii in xrange(0,len(freqs)):
        arfcns[ii] = get_arfcn_from_freq(freqs[ii],region)
    
    return arfcns

def get_arfcn_from_freq(freq,region):
	freq = freq / 1e6
	# GSM 450
	if freq <= 450.6 + 0.2*(293 - 259) + 10:
		arfcn = ((freq - (450.6 + 10)) / 0.2) + 259
	# GSM 480
	elif freq <= 479 + 0.2*(340 - 306) + 10:
		arfcn = ((freq - (479 + 10)) / 0.2) + 306
	# GSM 850
	elif freq <= 824.2 + 0.2*(251 - 128) + 45:
		arfcn = ((freq - (824.2 + 45)) / 0.2) + 128
	#E/R-GSM 900
	elif freq <= 890 + 0.2*(1023 - 1024) + 45:
		arfcn = ((freq - (890 + 45)) / -0.2) + 955
	# GSM 900
	elif freq <= 890 + 0.2*124 + 45:
		arfcn = (freq - (890 + 45)) / 0.2
	else:
		if region is "u":
			if freq > 1850.2 + 0.2*(810 - 512) + 80:
				arfcn = 0;
			else:
				arfcn = (freq - (1850.2 + 80) / 0.2) + 512
		elif region is "e":
			if freq > 1710.2 + 0.2*(885 - 512) + 95:
				arfcn = 0;
			else:
				arfcn = (freq - (1710.2 + 95) / 0.2) + 512
		else:
			arfcn = 0

	if arfcn<0:
		return 255
	else:
		return round(arfcn)
	

if __name__ == '__main__':
    parser = OptionParser(option_class=eng_option, usage="%prog: [options]")
    parser.add_option("", "--length", dest="length", type="eng_float", default=eng_notation.num_to_str(0.2),
        help="Set length [default=%default]")
    parser.add_option("", "--gain", dest="gain", type="intx", default=30,
        help="Set gain [default=%default]")
    parser.add_option("", "--channelizer-osr", dest="channelizer_osr", type="intx", default=2,
        help="Set channelizer_osr [default=%default]")
    parser.add_option("", "--fc", dest="fc", type="eng_float", default=eng_notation.num_to_str(937e6),
        help="Set fc [default=%default]")
    parser.add_option("", "--usrp-decim", dest="usrp_decim", type="intx", default=5,
        help="Set usrp_decim [default=%default]")
    parser.add_option("", "--fs", dest="fs", type="eng_float", default=eng_notation.num_to_str(100e6),
        help="Set fs [default=%default]")
    (options, args) = parser.parse_args()
    tb = gsm_receiver_usrp_channelizer_python(length=options.length, gain=options.gain, channelizer_osr=options.channelizer_osr, fc=options.fc, usrp_decim=options.usrp_decim, fs=options.fs)
    tb.start()
    tb.wait()