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

   1 #!/usr/bin/env python
   2 ##################################################
   3 # Gnuradio Python Flow Graph
   4 # Title: USRP HRPT Receiver
   5 # Generated: Mon Nov  2 08:30:47 2009
   6 ##################################################
   7
   8 from gnuradio import eng_notation
   9 from gnuradio import gr
  10 from gnuradio import noaa
  11 from gnuradio import window
  12 from gnuradio.eng_option import eng_option
  13 from gnuradio.gr import firdes
  14 from gnuradio.wxgui import fftsink2
  15 from gnuradio.wxgui import forms
  16 from gnuradio.wxgui import scopesink2
  17 from grc_gnuradio import wxgui as grc_wxgui
  18 from optparse import OptionParser
  19 import ConfigParser
  20 import math, os
  21 import wx
  22
  23 class file_rx_hrpt(grc_wxgui.top_block_gui):
  24
  25         def __init__(self, input_filename='usrp.dat', decim=16):
  26                 grc_wxgui.top_block_gui.__init__(self, title="USRP HRPT Receiver")
  27
  28                 ##################################################
  29                 # Parameters
  30                 ##################################################
  31                 self.input_filename = input_filename
  32                 self.decim = decim
  33
  34                 ##################################################
  35                 # Variables
  36                 ##################################################
  37                 self.sym_rate = sym_rate = 600*1109
  38                 self.sample_rate = sample_rate = 64e6/decim
  39                 self.config_filename = config_filename = os.environ['HOME']+'/.gnuradio/config.conf'
  40                 self.sps = sps = sample_rate/sym_rate
  41                 self._saved_pll_alpha_config = ConfigParser.ConfigParser()
  42                 self._saved_pll_alpha_config.read(config_filename)
  43                 try: saved_pll_alpha = self._saved_pll_alpha_config.getfloat('usrp_rx_hrpt', 'pll_alpha')
  44                 except: saved_pll_alpha = 0.05
  45                 self.saved_pll_alpha = saved_pll_alpha
  46                 self._saved_clock_alpha_config = ConfigParser.ConfigParser()
  47                 self._saved_clock_alpha_config.read(config_filename)
  48                 try: saved_clock_alpha = self._saved_clock_alpha_config.getfloat('usrp_rx_hrpt', 'clock_alpha')
  49                 except: saved_clock_alpha = 0.05
  50                 self.saved_clock_alpha = saved_clock_alpha
  51                 self._side_config = ConfigParser.ConfigParser()
  52                 self._side_config.read(config_filename)
  53                 try: side = self._side_config.get('usrp_rx_hrpt', 'side')
  54                 except: side = 'A'
  55                 self.side = side
  56                 self.pll_alpha = pll_alpha = saved_pll_alpha
  57                 self._output_filename_config = ConfigParser.ConfigParser()
  58                 self._output_filename_config.read(config_filename)
  59                 try: output_filename = self._output_filename_config.get('usrp_rx_hrpt', 'filename')
  60                 except: output_filename = 'frames.dat'
  61                 self.output_filename = output_filename
  62                 self.max_clock_offset = max_clock_offset = 0.1
  63                 self.max_carrier_offset = max_carrier_offset = 2*math.pi*100e3/sample_rate
  64                 self.hs = hs = int(sps/2.0)
  65                 self.clock_alpha = clock_alpha = saved_clock_alpha
  66
  67                 ##################################################
  68                 # Notebooks
  69                 ##################################################
  70                 self.displays = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
  71                 self.displays.AddPage(grc_wxgui.Panel(self.displays), "Spectrum")
  72                 self.displays.AddPage(grc_wxgui.Panel(self.displays), "Demod")
  73                 self.GridAdd(self.displays, 1, 0, 1, 2)
  74
  75                 ##################################################
  76                 # Controls
  77                 ##################################################
  78                 _pll_alpha_sizer = wx.BoxSizer(wx.VERTICAL)
  79                 self._pll_alpha_text_box = forms.text_box(
  80                         parent=self.GetWin(),
  81                         sizer=_pll_alpha_sizer,
  82                         value=self.pll_alpha,
  83                         callback=self.set_pll_alpha,
  84                         label="PLL Alpha",
  85                         converter=forms.float_converter(),
  86                         proportion=0,
  87                 )
  88                 self._pll_alpha_slider = forms.slider(
  89                         parent=self.GetWin(),
  90                         sizer=_pll_alpha_sizer,
  91                         value=self.pll_alpha,
  92                         callback=self.set_pll_alpha,
  93                         minimum=0.0,
  94                         maximum=0.5,
  95                         num_steps=100,
  96                         style=wx.SL_HORIZONTAL,
  97                         cast=float,
  98                         proportion=1,
  99                 )
 100                 self.GridAdd(_pll_alpha_sizer, 0, 0, 1, 1)
 101                 _clock_alpha_sizer = wx.BoxSizer(wx.VERTICAL)
 102                 self._clock_alpha_text_box = forms.text_box(
 103                         parent=self.GetWin(),
 104                         sizer=_clock_alpha_sizer,
 105                         value=self.clock_alpha,
 106                         callback=self.set_clock_alpha,
 107                         label="Clock Alpha",
 108                         converter=forms.float_converter(),
 109                         proportion=0,
 110                 )
 111                 self._clock_alpha_slider = forms.slider(
 112                         parent=self.GetWin(),
 113                         sizer=_clock_alpha_sizer,
 114                         value=self.clock_alpha,
 115                         callback=self.set_clock_alpha,
 116                         minimum=0.0,
 117                         maximum=0.5,
 118                         num_steps=100,
 119                         style=wx.SL_HORIZONTAL,
 120                         cast=float,
 121                         proportion=1,
 122                 )
 123                 self.GridAdd(_clock_alpha_sizer, 0, 1, 1, 1)
 124
 125                 ##################################################
 126                 # Blocks
 127                 ##################################################
 128                 self.agc = gr.agc_cc(1e-6, 1.0, 1.0, 1.0)
 129                 self.decoder = noaa.hrpt_decoder()
 130                 self.deframer = noaa.hrpt_deframer()
 131                 self.demod_scope = scopesink2.scope_sink_f(
 132                         self.displays.GetPage(1).GetWin(),
 133                         title="Post-Demod",
 134                         sample_rate=sym_rate*2.0,
 135                         v_scale=0.5,
 136                         v_offset=0,
 137                         t_scale=10.0/sym_rate,
 138                         ac_couple=False,
 139                         xy_mode=False,
 140                         num_inputs=1,
 141                 )
 142                 self.displays.GetPage(1).GridAdd(self.demod_scope.win, 0, 0, 1, 1)
 143                 self.frame_sink = gr.file_sink(gr.sizeof_short*1, output_filename)
 144                 self.gr_binary_slicer_fb_0 = gr.binary_slicer_fb()
 145                 self.gr_clock_recovery_mm_xx_0 = gr.clock_recovery_mm_ff(sps/2.0, clock_alpha**2/4.0, 0.5, clock_alpha, max_clock_offset)
 146                 self.gr_file_source_0 = gr.file_source(gr.sizeof_short*1, input_filename, False)
 147                 self.gr_interleaved_short_to_complex_0 = gr.interleaved_short_to_complex()
 148                 self.gr_moving_average_xx_0 = gr.moving_average_ff(hs, 1.0/hs, 4000)
 149                 self.pll = noaa.hrpt_pll_cf(pll_alpha, pll_alpha**2/4.0, max_carrier_offset)
 150                 self.rx_fft = fftsink2.fft_sink_c(
 151                         self.displays.GetPage(0).GetWin(),
 152                         baseband_freq=0,
 153                         y_per_div=5,
 154                         y_divs=8,
 155                         ref_level=-5,
 156                         ref_scale=2.0,
 157                         sample_rate=sample_rate,
 158                         fft_size=1024,
 159                         fft_rate=15,
 160                         average=True,
 161                         avg_alpha=0.1,
 162                         title="RX Spectrum",
 163                         peak_hold=False,
 164                         size=(640, 360),
 165                 )
 166                 self.displays.GetPage(0).GridAdd(self.rx_fft.win, 0, 0, 1, 1)
 167                 self.throttle = gr.throttle(gr.sizeof_short*1, sample_rate)
 168
 169                 ##################################################
 170                 # Connections
 171                 ##################################################
 172                 self.connect((self.gr_clock_recovery_mm_xx_0, 0), (self.gr_binary_slicer_fb_0, 0))
 173                 self.connect((self.deframer, 0), (self.frame_sink, 0))
 174                 self.connect((self.deframer, 0), (self.decoder, 0))
 175                 self.connect((self.gr_clock_recovery_mm_xx_0, 0), (self.demod_scope, 0))
 176                 self.connect((self.gr_moving_average_xx_0, 0), (self.gr_clock_recovery_mm_xx_0, 0))
 177                 self.connect((self.pll, 0), (self.gr_moving_average_xx_0, 0))
 178                 self.connect((self.agc, 0), (self.pll, 0))
 179                 self.connect((self.agc, 0), (self.rx_fft, 0))
 180                 self.connect((self.gr_interleaved_short_to_complex_0, 0), (self.agc, 0))
 181                 self.connect((self.throttle, 0), (self.gr_interleaved_short_to_complex_0, 0))
 182                 self.connect((self.gr_file_source_0, 0), (self.throttle, 0))
 183                 self.connect((self.gr_binary_slicer_fb_0, 0), (self.deframer, 0))
 184
 185         def set_input_filename(self, input_filename):
 186                 self.input_filename = input_filename
 187
 188         def set_decim(self, decim):
 189                 self.decim = decim
 190                 self.set_sample_rate(64e6/self.decim)
 191
 192         def set_sym_rate(self, sym_rate):
 193                 self.sym_rate = sym_rate
 194                 self.set_sps(self.sample_rate/self.sym_rate)
 195                 self.demod_scope.set_sample_rate(self.sym_rate*2.0)
 196
 197         def set_sample_rate(self, sample_rate):
 198                 self.sample_rate = sample_rate
 199                 self.set_max_carrier_offset(2*math.pi*100e3/self.sample_rate)
 200                 self.set_sps(self.sample_rate/self.sym_rate)
 201                 self.rx_fft.set_sample_rate(self.sample_rate)
 202
 203         def set_config_filename(self, config_filename):
 204                 self.config_filename = config_filename
 205                 self._side_config = ConfigParser.ConfigParser()
 206                 self._side_config.read(self.config_filename)
 207                 if not self._side_config.has_section('usrp_rx_hrpt'):
 208                         self._side_config.add_section('usrp_rx_hrpt')
 209                 self._side_config.set('usrp_rx_hrpt', 'side', str(self.side))
 210                 self._side_config.write(open(self.config_filename, 'w'))
 211                 self._saved_pll_alpha_config = ConfigParser.ConfigParser()
 212                 self._saved_pll_alpha_config.read(self.config_filename)
 213                 if not self._saved_pll_alpha_config.has_section('usrp_rx_hrpt'):
 214                         self._saved_pll_alpha_config.add_section('usrp_rx_hrpt')
 215                 self._saved_pll_alpha_config.set('usrp_rx_hrpt', 'pll_alpha', str(self.pll_alpha))
 216                 self._saved_pll_alpha_config.write(open(self.config_filename, 'w'))
 217                 self._saved_clock_alpha_config = ConfigParser.ConfigParser()
 218                 self._saved_clock_alpha_config.read(self.config_filename)
 219                 if not self._saved_clock_alpha_config.has_section('usrp_rx_hrpt'):
 220                         self._saved_clock_alpha_config.add_section('usrp_rx_hrpt')
 221                 self._saved_clock_alpha_config.set('usrp_rx_hrpt', 'clock_alpha', str(self.clock_alpha))
 222                 self._saved_clock_alpha_config.write(open(self.config_filename, 'w'))
 223                 self._output_filename_config = ConfigParser.ConfigParser()
 224                 self._output_filename_config.read(self.config_filename)
 225                 if not self._output_filename_config.has_section('usrp_rx_hrpt'):
 226                         self._output_filename_config.add_section('usrp_rx_hrpt')
 227                 self._output_filename_config.set('usrp_rx_hrpt', 'filename', str(self.output_filename))
 228                 self._output_filename_config.write(open(self.config_filename, 'w'))
 229
 230         def set_sps(self, sps):
 231                 self.sps = sps
 232                 self.set_hs(int(self.sps/2.0))
 233                 self.gr_clock_recovery_mm_xx_0.set_omega(self.sps/2.0)
 234
 235         def set_saved_pll_alpha(self, saved_pll_alpha):
 236                 self.saved_pll_alpha = saved_pll_alpha
 237                 self.set_pll_alpha(self.saved_pll_alpha)
 238
 239         def set_saved_clock_alpha(self, saved_clock_alpha):
 240                 self.saved_clock_alpha = saved_clock_alpha
 241                 self.set_clock_alpha(self.saved_clock_alpha)
 242
 243         def set_side(self, side):
 244                 self.side = side
 245                 self._side_config = ConfigParser.ConfigParser()
 246                 self._side_config.read(self.config_filename)
 247                 if not self._side_config.has_section('usrp_rx_hrpt'):
 248                         self._side_config.add_section('usrp_rx_hrpt')
 249                 self._side_config.set('usrp_rx_hrpt', 'side', str(self.side))
 250                 self._side_config.write(open(self.config_filename, 'w'))
 251
 252         def set_pll_alpha(self, pll_alpha):
 253                 self.pll_alpha = pll_alpha
 254                 self.pll.set_alpha(self.pll_alpha)
 255                 self.pll.set_beta(self.pll_alpha**2/4.0)
 256                 self._pll_alpha_slider.set_value(self.pll_alpha)
 257                 self._pll_alpha_text_box.set_value(self.pll_alpha)
 258                 self._saved_pll_alpha_config = ConfigParser.ConfigParser()
 259                 self._saved_pll_alpha_config.read(self.config_filename)
 260                 if not self._saved_pll_alpha_config.has_section('usrp_rx_hrpt'):
 261                         self._saved_pll_alpha_config.add_section('usrp_rx_hrpt')
 262                 self._saved_pll_alpha_config.set('usrp_rx_hrpt', 'pll_alpha', str(self.pll_alpha))
 263                 self._saved_pll_alpha_config.write(open(self.config_filename, 'w'))
 264
 265         def set_output_filename(self, output_filename):
 266                 self.output_filename = output_filename
 267                 self._output_filename_config = ConfigParser.ConfigParser()
 268                 self._output_filename_config.read(self.config_filename)
 269                 if not self._output_filename_config.has_section('usrp_rx_hrpt'):
 270                         self._output_filename_config.add_section('usrp_rx_hrpt')
 271                 self._output_filename_config.set('usrp_rx_hrpt', 'filename', str(self.output_filename))
 272                 self._output_filename_config.write(open(self.config_filename, 'w'))
 273
 274         def set_max_clock_offset(self, max_clock_offset):
 275                 self.max_clock_offset = max_clock_offset
 276
 277         def set_max_carrier_offset(self, max_carrier_offset):
 278                 self.max_carrier_offset = max_carrier_offset
 279                 self.pll.set_max_offset(self.max_carrier_offset)
 280
 281         def set_hs(self, hs):
 282                 self.hs = hs
 283                 self.gr_moving_average_xx_0.set_length_and_scale(self.hs, 1.0/self.hs)
 284
 285         def set_clock_alpha(self, clock_alpha):
 286                 self.clock_alpha = clock_alpha
 287                 self.gr_clock_recovery_mm_xx_0.set_gain_omega(self.clock_alpha**2/4.0)
 288                 self.gr_clock_recovery_mm_xx_0.set_gain_mu(self.clock_alpha)
 289                 self._clock_alpha_slider.set_value(self.clock_alpha)
 290                 self._clock_alpha_text_box.set_value(self.clock_alpha)
 291                 self._saved_clock_alpha_config = ConfigParser.ConfigParser()
 292                 self._saved_clock_alpha_config.read(self.config_filename)
 293                 if not self._saved_clock_alpha_config.has_section('usrp_rx_hrpt'):
 294                         self._saved_clock_alpha_config.add_section('usrp_rx_hrpt')
 295                 self._saved_clock_alpha_config.set('usrp_rx_hrpt', 'clock_alpha', str(self.clock_alpha))
 296                 self._saved_clock_alpha_config.write(open(self.config_filename, 'w'))
 297
 298 if __name__ == '__main__':
 299         parser = OptionParser(option_class=eng_option, usage="%prog: [options]")
 300         parser.add_option("-F", "--input-filename", dest="input_filename", type="string", default='usrp.dat',
 301                 help="Set usrp.dat [default=%default]")
 302         parser.add_option("-d", "--decim", dest="decim", type="intx", default=16,
 303                 help="Set decim [default=%default]")
 304         (options, args) = parser.parse_args()
 305         tb = file_rx_hrpt(input_filename=options.input_filename, decim=options.decim)
 306         tb.Run(True)
 307