piotr | 442c46d | 2014-04-17 10:51:53 +0200 | [diff] [blame] | 1 | #!/usr/bin/env python |
| 2 | ################################################## |
| 3 | # Gnuradio Python Flow Graph |
| 4 | # Title: Gsm Receiver Usrp Channelizer Python |
| 5 | # Generated: Sun Feb 9 12:46:36 2014 |
| 6 | ################################################## |
| 7 | |
| 8 | from gnuradio import blocks |
| 9 | from gnuradio import eng_notation |
| 10 | from gnuradio import gr |
| 11 | from gnuradio import uhd |
| 12 | from gnuradio.eng_option import eng_option |
| 13 | from gnuradio.filter import firdes |
| 14 | from gnuradio.filter import pfb |
| 15 | from optparse import OptionParser |
| 16 | import gsm |
| 17 | import time |
| 18 | from numpy import fft |
| 19 | |
| 20 | |
| 21 | class gsm_receiver_usrp_channelizer_python(gr.top_block): |
| 22 | |
| 23 | def __init__(self, length=0.2, gain=25, channelizer_osr=1, fc=937e6, usrp_decim=4, fs=100e6): |
| 24 | gr.top_block.__init__(self, "Gsm Receiver Usrp Channelizer Python") |
| 25 | |
| 26 | ################################################## |
| 27 | # Parameters |
| 28 | ################################################## |
| 29 | self.length = length |
| 30 | self.gain = gain |
| 31 | self.channelizer_osr = channelizer_osr |
| 32 | self.fc = fc |
| 33 | self.usrp_decim = usrp_decim |
| 34 | self.channels_num = int(round(fs/usrp_decim/200e3)) |
| 35 | self.fs = fs |
| 36 | |
| 37 | ################################################## |
| 38 | # Variables |
| 39 | ################################################## |
| 40 | self.samp_rate = 100e6/self.usrp_decim |
| 41 | self.samp_rate_channelizer_out = self.samp_rate/self.channels_num*channelizer_osr |
| 42 | self.freqs = fft.fftfreq(self.channels_num,1/self.samp_rate)+self.fc |
| 43 | self.arfcns = get_arfcns_from_freqs(self.freqs,"e") |
| 44 | print self.freqs |
| 45 | print self.arfcns |
| 46 | |
| 47 | ################################################## |
| 48 | # Blocks |
| 49 | ################################################## |
| 50 | self.uhd_usrp_source_0 = uhd.usrp_source( |
| 51 | device_addr="addr=192.168.11.2", |
| 52 | stream_args=uhd.stream_args( |
| 53 | cpu_format="fc32", |
| 54 | otw_format="sc16", |
| 55 | channels=range(1), |
| 56 | ), |
| 57 | ) |
| 58 | self.uhd_usrp_source_0.set_samp_rate(self.samp_rate) |
| 59 | self.uhd_usrp_source_0.set_center_freq(fc, 0) |
| 60 | self.uhd_usrp_source_0.set_gain(gain, 0) |
| 61 | self.pfb_channelizer_ccf_0 = pfb.channelizer_ccf( |
| 62 | self.channels_num, |
| 63 | (), |
| 64 | channelizer_osr, |
| 65 | 100) |
| 66 | self.pfb_channelizer_ccf_0.set_channel_map(([])) |
| 67 | |
| 68 | self.blocks_head_0 = blocks.head(gr.sizeof_gr_complex*1, int(self.samp_rate*length)) |
| 69 | self.gsm_bursts_printer_0 = gsm.bursts_printer() |
| 70 | |
| 71 | self.connect((self.uhd_usrp_source_0, 0), (self.blocks_head_0, 0)) |
| 72 | self.connect((self.blocks_head_0, 0), (self.pfb_channelizer_ccf_0, 0)) |
| 73 | |
| 74 | self.gsm_receiver_hier = {} |
| 75 | |
| 76 | for ii in xrange(0,self.channels_num): |
| 77 | self.gsm_receiver_hier[ii] = gsm.receiver_hier(self.samp_rate_channelizer_out, 4, int(self.freqs[ii]/1e5)) |
| 78 | self.connect((self.pfb_channelizer_ccf_0, ii), (self.gsm_receiver_hier[ii], 0)) |
| 79 | self.msg_connect(self.gsm_receiver_hier[ii], "bursts", self.gsm_bursts_printer_0, "bursts") |
| 80 | |
| 81 | |
| 82 | # QT sink close method reimplementation |
| 83 | |
| 84 | def get_length(self): |
| 85 | return self.length |
| 86 | |
| 87 | def set_length(self, length): |
| 88 | self.length = length |
| 89 | |
| 90 | def get_gain(self): |
| 91 | return self.gain |
| 92 | |
| 93 | def set_gain(self, gain): |
| 94 | self.gain = gain |
| 95 | self.uhd_usrp_source_0.set_gain(self.gain, 0) |
| 96 | |
| 97 | def get_channelizer_osr(self): |
| 98 | return self.channelizer_osr |
| 99 | |
| 100 | def set_channelizer_osr(self, channelizer_osr): |
| 101 | self.channelizer_osr = channelizer_osr |
| 102 | self.set_samp_rate_channelizer_out(self.samp_rate/self.channels_num*self.channelizer_osr) |
| 103 | |
| 104 | def get_fc(self): |
| 105 | return self.fc |
| 106 | |
| 107 | def set_fc(self, fc): |
| 108 | self.fc = fc |
| 109 | self.uhd_usrp_source_0.set_center_freq(self.fc, 0) |
| 110 | |
| 111 | def get_usrp_decim(self): |
| 112 | return self.usrp_decim |
| 113 | |
| 114 | def set_usrp_decim(self, usrp_decim): |
| 115 | self.usrp_decim = usrp_decim |
| 116 | self.set_samp_rate(100e6/self.usrp_decim) |
| 117 | |
| 118 | def get_channels_num(self): |
| 119 | return self.channels_num |
| 120 | |
| 121 | def set_channels_num(self, channels_num): |
| 122 | self.channels_num = channels_num |
| 123 | self.set_samp_rate_channelizer_out(self.samp_rate/self.channels_num*self.channelizer_osr) |
| 124 | |
| 125 | def get_fs(self): |
| 126 | return self.fs |
| 127 | |
| 128 | def set_fs(self, fs): |
| 129 | self.fs = fs |
| 130 | |
| 131 | def get_samp_rate(self): |
| 132 | return self.samp_rate |
| 133 | |
| 134 | def set_samp_rate(self, samp_rate): |
| 135 | self.samp_rate = samp_rate |
| 136 | self.set_samp_rate_channelizer_out(self.samp_rate/self.channels_num*self.channelizer_osr) |
| 137 | self.uhd_usrp_source_0.set_samp_rate(self.samp_rate) |
| 138 | |
| 139 | def get_samp_rate_channelizer_out(self): |
| 140 | return self.samp_rate_channelizer_out |
| 141 | |
| 142 | def set_samp_rate_channelizer_out(self, samp_rate_channelizer_out): |
| 143 | self.samp_rate_channelizer_out = samp_rate_channelizer_out |
| 144 | |
| 145 | def get_arfcns_from_freqs(freqs,region): |
| 146 | arfcns = {} |
| 147 | for ii in xrange(0,len(freqs)): |
| 148 | arfcns[ii] = get_arfcn_from_freq(freqs[ii],region) |
| 149 | |
| 150 | return arfcns |
| 151 | |
| 152 | def get_arfcn_from_freq(freq,region): |
| 153 | freq = freq / 1e6 |
| 154 | # GSM 450 |
| 155 | if freq <= 450.6 + 0.2*(293 - 259) + 10: |
| 156 | arfcn = ((freq - (450.6 + 10)) / 0.2) + 259 |
| 157 | # GSM 480 |
| 158 | elif freq <= 479 + 0.2*(340 - 306) + 10: |
| 159 | arfcn = ((freq - (479 + 10)) / 0.2) + 306 |
| 160 | # GSM 850 |
| 161 | elif freq <= 824.2 + 0.2*(251 - 128) + 45: |
| 162 | arfcn = ((freq - (824.2 + 45)) / 0.2) + 128 |
| 163 | #E/R-GSM 900 |
| 164 | elif freq <= 890 + 0.2*(1023 - 1024) + 45: |
| 165 | arfcn = ((freq - (890 + 45)) / -0.2) + 955 |
| 166 | # GSM 900 |
| 167 | elif freq <= 890 + 0.2*124 + 45: |
| 168 | arfcn = (freq - (890 + 45)) / 0.2 |
| 169 | else: |
| 170 | if region is "u": |
| 171 | if freq > 1850.2 + 0.2*(810 - 512) + 80: |
| 172 | arfcn = 0; |
| 173 | else: |
| 174 | arfcn = (freq - (1850.2 + 80) / 0.2) + 512 |
| 175 | elif region is "e": |
| 176 | if freq > 1710.2 + 0.2*(885 - 512) + 95: |
| 177 | arfcn = 0; |
| 178 | else: |
| 179 | arfcn = (freq - (1710.2 + 95) / 0.2) + 512 |
| 180 | else: |
| 181 | arfcn = 0 |
| 182 | |
| 183 | if arfcn<0: |
| 184 | return 255 |
| 185 | else: |
| 186 | return round(arfcn) |
| 187 | |
| 188 | |
| 189 | if __name__ == '__main__': |
| 190 | parser = OptionParser(option_class=eng_option, usage="%prog: [options]") |
| 191 | parser.add_option("", "--length", dest="length", type="eng_float", default=eng_notation.num_to_str(0.2), |
| 192 | help="Set length [default=%default]") |
| 193 | parser.add_option("", "--gain", dest="gain", type="intx", default=30, |
| 194 | help="Set gain [default=%default]") |
| 195 | parser.add_option("", "--channelizer-osr", dest="channelizer_osr", type="intx", default=2, |
| 196 | help="Set channelizer_osr [default=%default]") |
| 197 | parser.add_option("", "--fc", dest="fc", type="eng_float", default=eng_notation.num_to_str(937e6), |
| 198 | help="Set fc [default=%default]") |
| 199 | parser.add_option("", "--usrp-decim", dest="usrp_decim", type="intx", default=5, |
| 200 | help="Set usrp_decim [default=%default]") |
| 201 | parser.add_option("", "--fs", dest="fs", type="eng_float", default=eng_notation.num_to_str(100e6), |
| 202 | help="Set fs [default=%default]") |
| 203 | (options, args) = parser.parse_args() |
| 204 | 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) |
| 205 | tb.start() |
| 206 | tb.wait() |
| 207 | |
| 208 | |