git.gag.com Git - debian/gnuradio/blob - gr-noaa/apps/usrp_rx_hrpt2.py

   1 #!/usr/bin/env python
   2 ##################################################
   3 # Gnuradio Python Flow Graph
   4 # Title: USRP HRPT Receiver
   5 # Generated: Sun Sep 27 13:32:48 2009
   6 ##################################################
   7
   8 from gnuradio import eng_notation
   9 from gnuradio import gr
  10 from gnuradio import noaa
  11 from gnuradio.eng_option import eng_option
  12 from gnuradio.gr import firdes
  13 from gnuradio.wxgui import forms
  14 from gnuradio.wxgui import scopesink2
  15 from grc_gnuradio import usrp as grc_usrp
  16 from grc_gnuradio import wxgui as grc_wxgui
  17 from optparse import OptionParser
  18 import ConfigParser
  19 import math
  20 import wx
  21
  22 class usrp_rx_hrpt2(grc_wxgui.top_block_gui):
  23
  24         def __init__(self):
  25                 grc_wxgui.top_block_gui.__init__(self, title="USRP HRPT Receiver")
  26
  27                 ##################################################
  28                 # Variables
  29                 ##################################################
  30                 self.config_filename = config_filename = 'usrp_rx_hrpt.cfg'
  31                 self._decim_config = ConfigParser.ConfigParser()
  32                 self._decim_config.read(config_filename)
  33                 try: decim = self._decim_config.getfloat('usrp', 'decim')
  34                 except: decim = 16
  35                 self.decim = decim
  36                 self.sym_rate = sym_rate = 600*1109
  37                 self.sample_rate = sample_rate = 64e6/decim
  38                 self.sps = sps = sample_rate/sym_rate
  39                 self._side_config = ConfigParser.ConfigParser()
  40                 self._side_config.read(config_filename)
  41                 try: side = self._side_config.get('usrp', 'side')
  42                 except: side = 'A'
  43                 self.side = side
  44                 self._saved_sync_alpha_config = ConfigParser.ConfigParser()
  45                 self._saved_sync_alpha_config.read(config_filename)
  46                 try: saved_sync_alpha = self._saved_sync_alpha_config.getfloat('demod', 'sync_alpha')
  47                 except: saved_sync_alpha = 0.05
  48                 self.saved_sync_alpha = saved_sync_alpha
  49                 self._saved_pll_alpha_config = ConfigParser.ConfigParser()
  50                 self._saved_pll_alpha_config.read(config_filename)
  51                 try: saved_pll_alpha = self._saved_pll_alpha_config.getfloat('demod', 'pll_alpha')
  52                 except: saved_pll_alpha = 0.05
  53                 self.saved_pll_alpha = saved_pll_alpha
  54                 self._saved_gain_config = ConfigParser.ConfigParser()
  55                 self._saved_gain_config.read(config_filename)
  56                 try: saved_gain = self._saved_gain_config.getfloat('usrp', 'gain')
  57                 except: saved_gain = 35
  58                 self.saved_gain = saved_gain
  59                 self._saved_freq_config = ConfigParser.ConfigParser()
  60                 self._saved_freq_config.read(config_filename)
  61                 try: saved_freq = self._saved_freq_config.getfloat('usrp', 'freq')
  62                 except: saved_freq = 1698e6
  63                 self.saved_freq = saved_freq
  64                 self.hs = hs = int(sps/2.0)
  65                 self.sync_alpha = sync_alpha = saved_sync_alpha
  66                 self.side_text = side_text = side
  67                 self.pll_alpha = pll_alpha = saved_pll_alpha
  68                 self._output_filename_config = ConfigParser.ConfigParser()
  69                 self._output_filename_config.read(config_filename)
  70                 try: output_filename = self._output_filename_config.get('output', 'filename')
  71                 except: output_filename = 'frames.dat'
  72                 self.output_filename = output_filename
  73                 self.mf_taps = mf_taps = [-0.5/hs,]*hs+[0.5/hs,]*hs
  74                 self.max_sync_offset = max_sync_offset = 0.01
  75                 self.max_carrier_offset = max_carrier_offset = 2*math.pi*100e3/sample_rate
  76                 self.gain = gain = saved_gain
  77                 self.freq = freq = saved_freq
  78                 self.decim_text = decim_text = decim
  79
  80                 ##################################################
  81                 # Controls
  82                 ##################################################
  83                 _sync_alpha_sizer = wx.BoxSizer(wx.VERTICAL)
  84                 self._sync_alpha_text_box = forms.text_box(
  85                         parent=self.GetWin(),
  86                         sizer=_sync_alpha_sizer,
  87                         value=self.sync_alpha,
  88                         callback=self.set_sync_alpha,
  89                         label="SYNC Alpha",
  90                         converter=forms.float_converter(),
  91                         proportion=0,
  92                 )
  93                 self._sync_alpha_slider = forms.slider(
  94                         parent=self.GetWin(),
  95                         sizer=_sync_alpha_sizer,
  96                         value=self.sync_alpha,
  97                         callback=self.set_sync_alpha,
  98                         minimum=0.0,
  99                         maximum=0.5,
 100                         num_steps=100,
 101                         style=wx.SL_HORIZONTAL,
 102                         cast=float,
 103                         proportion=1,
 104                 )
 105                 self.GridAdd(_sync_alpha_sizer, 0, 3, 1, 1)
 106                 self._side_text_static_text = forms.static_text(
 107                         parent=self.GetWin(),
 108                         value=self.side_text,
 109                         callback=self.set_side_text,
 110                         label="USRP Side",
 111                         converter=forms.str_converter(),
 112                 )
 113                 self.GridAdd(self._side_text_static_text, 1, 0, 1, 1)
 114                 _pll_alpha_sizer = wx.BoxSizer(wx.VERTICAL)
 115                 self._pll_alpha_text_box = forms.text_box(
 116                         parent=self.GetWin(),
 117                         sizer=_pll_alpha_sizer,
 118                         value=self.pll_alpha,
 119                         callback=self.set_pll_alpha,
 120                         label="PLL Alpha",
 121                         converter=forms.float_converter(),
 122                         proportion=0,
 123                 )
 124                 self._pll_alpha_slider = forms.slider(
 125                         parent=self.GetWin(),
 126                         sizer=_pll_alpha_sizer,
 127                         value=self.pll_alpha,
 128                         callback=self.set_pll_alpha,
 129                         minimum=0.0,
 130                         maximum=0.5,
 131                         num_steps=100,
 132                         style=wx.SL_HORIZONTAL,
 133                         cast=float,
 134                         proportion=1,
 135                 )
 136                 self.GridAdd(_pll_alpha_sizer, 0, 2, 1, 1)
 137                 _gain_sizer = wx.BoxSizer(wx.VERTICAL)
 138                 self._gain_text_box = forms.text_box(
 139                         parent=self.GetWin(),
 140                         sizer=_gain_sizer,
 141                         value=self.gain,
 142                         callback=self.set_gain,
 143                         label="RX Gain",
 144                         converter=forms.float_converter(),
 145                         proportion=0,
 146                 )
 147                 self._gain_slider = forms.slider(
 148                         parent=self.GetWin(),
 149                         sizer=_gain_sizer,
 150                         value=self.gain,
 151                         callback=self.set_gain,
 152                         minimum=0,
 153                         maximum=100,
 154                         num_steps=100,
 155                         style=wx.SL_HORIZONTAL,
 156                         cast=float,
 157                         proportion=1,
 158                 )
 159                 self.GridAdd(_gain_sizer, 0, 1, 1, 1)
 160                 self._freq_text_box = forms.text_box(
 161                         parent=self.GetWin(),
 162                         value=self.freq,
 163                         callback=self.set_freq,
 164                         label="Frequency",
 165                         converter=forms.float_converter(),
 166                 )
 167                 self.GridAdd(self._freq_text_box, 0, 0, 1, 1)
 168                 self._decim_text_static_text = forms.static_text(
 169                         parent=self.GetWin(),
 170                         value=self.decim_text,
 171                         callback=self.set_decim_text,
 172                         label="Decimation",
 173                         converter=forms.float_converter(),
 174                 )
 175                 self.GridAdd(self._decim_text_static_text, 1, 1, 1, 1)
 176
 177                 ##################################################
 178                 # Blocks
 179                 ##################################################
 180                 self.agc = gr.agc_cc(1e-6, 1.0, 1.0, 1.0)
 181                 self.decoder = noaa.hrpt_decoder()
 182                 self.deframer = noaa.hrpt_deframer()
 183                 self.frame_sink = gr.file_sink(gr.sizeof_short*1, output_filename)
 184                 self.gr_fir_filter_xxx_0 = gr.fir_filter_ccc(1, (mf_taps))
 185                 self.pll = noaa.hrpt_pll_cf(pll_alpha, pll_alpha**2/4.0, max_carrier_offset)
 186                 self.pll_scope = scopesink2.scope_sink_f(
 187                         self.GetWin(),
 188                         title="Demod Waveform",
 189                         sample_rate=sample_rate,
 190                         v_scale=0.5,
 191                         t_scale=20.0/sample_rate,
 192                         ac_couple=False,
 193                         xy_mode=False,
 194                         num_inputs=1,
 195                 )
 196                 self.GridAdd(self.pll_scope.win, 2, 0, 1, 4)
 197                 self.sync = noaa.hrpt_sync_fb(sync_alpha, sync_alpha**2/4.0, sps, max_sync_offset)
 198                 self.usrp_source = grc_usrp.simple_source_c(which=0, side=side, rx_ant="RXA")
 199                 self.usrp_source.set_decim_rate(decim)
 200                 self.usrp_source.set_frequency(freq, verbose=True)
 201                 self.usrp_source.set_gain(gain)
 202
 203                 ##################################################
 204                 # Connections
 205                 ##################################################
 206                 self.connect((self.gr_fir_filter_xxx_0, 0), (self.pll, 0))
 207                 self.connect((self.agc, 0), (self.gr_fir_filter_xxx_0, 0))
 208                 self.connect((self.usrp_source, 0), (self.agc, 0))
 209                 self.connect((self.deframer, 0), (self.decoder, 0))
 210                 self.connect((self.pll, 0), (self.pll_scope, 0))
 211                 self.connect((self.pll, 0), (self.sync, 0))
 212                 self.connect((self.sync, 0), (self.deframer, 0))
 213                 self.connect((self.deframer, 0), (self.frame_sink, 0))
 214
 215         def set_config_filename(self, config_filename):
 216                 self.config_filename = config_filename
 217                 self._side_config = ConfigParser.ConfigParser()
 218                 self._side_config.read(self.config_filename)
 219                 if not self._side_config.has_section('usrp'):
 220                         self._side_config.add_section('usrp')
 221                 self._side_config.set('usrp', 'side', str(self.side))
 222                 self._side_config.write(open(self.config_filename, 'w'))
 223                 self._decim_config = ConfigParser.ConfigParser()
 224                 self._decim_config.read(self.config_filename)
 225                 if not self._decim_config.has_section('usrp'):
 226                         self._decim_config.add_section('usrp')
 227                 self._decim_config.set('usrp', 'decim', str(self.decim))
 228                 self._decim_config.write(open(self.config_filename, 'w'))
 229                 self._saved_freq_config = ConfigParser.ConfigParser()
 230                 self._saved_freq_config.read(self.config_filename)
 231                 if not self._saved_freq_config.has_section('usrp'):
 232                         self._saved_freq_config.add_section('usrp')
 233                 self._saved_freq_config.set('usrp', 'freq', str(self.freq))
 234                 self._saved_freq_config.write(open(self.config_filename, 'w'))
 235                 self._saved_gain_config = ConfigParser.ConfigParser()
 236                 self._saved_gain_config.read(self.config_filename)
 237                 if not self._saved_gain_config.has_section('usrp'):
 238                         self._saved_gain_config.add_section('usrp')
 239                 self._saved_gain_config.set('usrp', 'gain', str(self.gain))
 240                 self._saved_gain_config.write(open(self.config_filename, 'w'))
 241                 self._saved_pll_alpha_config = ConfigParser.ConfigParser()
 242                 self._saved_pll_alpha_config.read(self.config_filename)
 243                 if not self._saved_pll_alpha_config.has_section('demod'):
 244                         self._saved_pll_alpha_config.add_section('demod')
 245                 self._saved_pll_alpha_config.set('demod', 'pll_alpha', str(self.pll_alpha))
 246                 self._saved_pll_alpha_config.write(open(self.config_filename, 'w'))
 247                 self._saved_sync_alpha_config = ConfigParser.ConfigParser()
 248                 self._saved_sync_alpha_config.read(self.config_filename)
 249                 if not self._saved_sync_alpha_config.has_section('demod'):
 250                         self._saved_sync_alpha_config.add_section('demod')
 251                 self._saved_sync_alpha_config.set('demod', 'sync_alpha', str(self.sync_alpha))
 252                 self._saved_sync_alpha_config.write(open(self.config_filename, 'w'))
 253                 self._output_filename_config = ConfigParser.ConfigParser()
 254                 self._output_filename_config.read(self.config_filename)
 255                 if not self._output_filename_config.has_section('output'):
 256                         self._output_filename_config.add_section('output')
 257                 self._output_filename_config.set('output', 'filename', str(self.output_filename))
 258                 self._output_filename_config.write(open(self.config_filename, 'w'))
 259
 260         def set_decim(self, decim):
 261                 self.decim = decim
 262                 self.set_sample_rate(64e6/self.decim)
 263                 self._decim_config = ConfigParser.ConfigParser()
 264                 self._decim_config.read(self.config_filename)
 265                 if not self._decim_config.has_section('usrp'):
 266                         self._decim_config.add_section('usrp')
 267                 self._decim_config.set('usrp', 'decim', str(self.decim))
 268                 self._decim_config.write(open(self.config_filename, 'w'))
 269                 self.set_decim_text(self.decim)
 270                 self.usrp_source.set_decim_rate(self.decim)
 271
 272         def set_sym_rate(self, sym_rate):
 273                 self.sym_rate = sym_rate
 274                 self.set_sps(self.sample_rate/self.sym_rate)
 275
 276         def set_sample_rate(self, sample_rate):
 277                 self.sample_rate = sample_rate
 278                 self.set_max_carrier_offset(2*math.pi*100e3/self.sample_rate)
 279                 self.set_sps(self.sample_rate/self.sym_rate)
 280                 self.pll_scope.set_sample_rate(self.sample_rate)
 281
 282         def set_sps(self, sps):
 283                 self.sps = sps
 284                 self.set_hs(int(self.sps/2.0))
 285
 286         def set_side(self, side):
 287                 self.side = side
 288                 self.set_side_text(self.side)
 289                 self._side_config = ConfigParser.ConfigParser()
 290                 self._side_config.read(self.config_filename)
 291                 if not self._side_config.has_section('usrp'):
 292                         self._side_config.add_section('usrp')
 293                 self._side_config.set('usrp', 'side', str(self.side))
 294                 self._side_config.write(open(self.config_filename, 'w'))
 295
 296         def set_saved_sync_alpha(self, saved_sync_alpha):
 297                 self.saved_sync_alpha = saved_sync_alpha
 298                 self.set_sync_alpha(self.saved_sync_alpha)
 299
 300         def set_saved_pll_alpha(self, saved_pll_alpha):
 301                 self.saved_pll_alpha = saved_pll_alpha
 302                 self.set_pll_alpha(self.saved_pll_alpha)
 303
 304         def set_saved_gain(self, saved_gain):
 305                 self.saved_gain = saved_gain
 306                 self.set_gain(self.saved_gain)
 307
 308         def set_saved_freq(self, saved_freq):
 309                 self.saved_freq = saved_freq
 310                 self.set_freq(self.saved_freq)
 311
 312         def set_hs(self, hs):
 313                 self.hs = hs
 314                 self.set_mf_taps([-0.5/self.hs,]*self.hs+[0.5/self.hs,]*self.hs)
 315
 316         def set_sync_alpha(self, sync_alpha):
 317                 self.sync_alpha = sync_alpha
 318                 self._sync_alpha_slider.set_value(self.sync_alpha)
 319                 self._sync_alpha_text_box.set_value(self.sync_alpha)
 320                 self._saved_sync_alpha_config = ConfigParser.ConfigParser()
 321                 self._saved_sync_alpha_config.read(self.config_filename)
 322                 if not self._saved_sync_alpha_config.has_section('demod'):
 323                         self._saved_sync_alpha_config.add_section('demod')
 324                 self._saved_sync_alpha_config.set('demod', 'sync_alpha', str(self.sync_alpha))
 325                 self._saved_sync_alpha_config.write(open(self.config_filename, 'w'))
 326                 self.sync.set_alpha(self.sync_alpha)
 327                 self.sync.set_beta(self.sync_alpha**2/4.0)
 328
 329         def set_side_text(self, side_text):
 330                 self.side_text = side_text
 331                 self._side_text_static_text.set_value(self.side_text)
 332
 333         def set_pll_alpha(self, pll_alpha):
 334                 self.pll_alpha = pll_alpha
 335                 self._pll_alpha_slider.set_value(self.pll_alpha)
 336                 self._pll_alpha_text_box.set_value(self.pll_alpha)
 337                 self._saved_pll_alpha_config = ConfigParser.ConfigParser()
 338                 self._saved_pll_alpha_config.read(self.config_filename)
 339                 if not self._saved_pll_alpha_config.has_section('demod'):
 340                         self._saved_pll_alpha_config.add_section('demod')
 341                 self._saved_pll_alpha_config.set('demod', 'pll_alpha', str(self.pll_alpha))
 342                 self._saved_pll_alpha_config.write(open(self.config_filename, 'w'))
 343                 self.pll.set_alpha(self.pll_alpha)
 344                 self.pll.set_beta(self.pll_alpha**2/4.0)
 345
 346         def set_output_filename(self, output_filename):
 347                 self.output_filename = output_filename
 348                 self._output_filename_config = ConfigParser.ConfigParser()
 349                 self._output_filename_config.read(self.config_filename)
 350                 if not self._output_filename_config.has_section('output'):
 351                         self._output_filename_config.add_section('output')
 352                 self._output_filename_config.set('output', 'filename', str(self.output_filename))
 353                 self._output_filename_config.write(open(self.config_filename, 'w'))
 354
 355         def set_mf_taps(self, mf_taps):
 356                 self.mf_taps = mf_taps
 357                 self.gr_fir_filter_xxx_0.set_taps((self.mf_taps))
 358
 359         def set_max_sync_offset(self, max_sync_offset):
 360                 self.max_sync_offset = max_sync_offset
 361                 self.sync.set_max_offset(self.max_sync_offset)
 362
 363         def set_max_carrier_offset(self, max_carrier_offset):
 364                 self.max_carrier_offset = max_carrier_offset
 365                 self.pll.set_max_offset(self.max_carrier_offset)
 366
 367         def set_gain(self, gain):
 368                 self.gain = gain
 369                 self._gain_slider.set_value(self.gain)
 370                 self._gain_text_box.set_value(self.gain)
 371                 self._saved_gain_config = ConfigParser.ConfigParser()
 372                 self._saved_gain_config.read(self.config_filename)
 373                 if not self._saved_gain_config.has_section('usrp'):
 374                         self._saved_gain_config.add_section('usrp')
 375                 self._saved_gain_config.set('usrp', 'gain', str(self.gain))
 376                 self._saved_gain_config.write(open(self.config_filename, 'w'))
 377                 self.usrp_source.set_gain(self.gain)
 378
 379         def set_freq(self, freq):
 380                 self.freq = freq
 381                 self._freq_text_box.set_value(self.freq)
 382                 self._saved_freq_config = ConfigParser.ConfigParser()
 383                 self._saved_freq_config.read(self.config_filename)
 384                 if not self._saved_freq_config.has_section('usrp'):
 385                         self._saved_freq_config.add_section('usrp')
 386                 self._saved_freq_config.set('usrp', 'freq', str(self.freq))
 387                 self._saved_freq_config.write(open(self.config_filename, 'w'))
 388                 self.usrp_source.set_frequency(self.freq)
 389
 390         def set_decim_text(self, decim_text):
 391                 self.decim_text = decim_text
 392                 self._decim_text_static_text.set_value(self.decim_text)
 393
 394 if __name__ == '__main__':
 395         parser = OptionParser(option_class=eng_option, usage="%prog: [options]")
 396         (options, args) = parser.parse_args()
 397         if gr.enable_realtime_scheduling() != gr.RT_OK:
 398                 print "Error: failed to enable realtime scheduling."
 399         tb = usrp_rx_hrpt2()
 400         tb.Run(True)
 401