text: #!/usr/bin/env python
  #
  # Copyright 2006,2007,2011 Free Software Foundation, Inc.
  # 
  # This file is part of GNU Radio
  # 
  # GNU Radio is free software; you can redistribute it and/or modify
  # it under the terms of the GNU General Public License as published by
  # the Free Software Foundation; either version 3, or (at your option)
  # any later version.
  # 
  # GNU Radio is distributed in the hope that it will be useful,
  # but WITHOUT ANY WARRANTY; without even the implied warranty of
  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  # GNU General Public License for more details.
  # 
  # You should have received a copy of the GNU General Public License
  # along with GNU Radio; see the file COPYING.  If not, write to
  # the Free Software Foundation, Inc., 51 Franklin Street,
  # Boston, MA 02110-1301, USA.
  # 
  
  from gnuradio import gr, blks2
  from gnuradio import eng_notation
  from gnuradio.eng_option import eng_option
  from optparse import OptionParser
  
  from gnuradio import digital
  
  # from current dir
  from receive_path import receive_path
  from uhd_interface import uhd_receiver
  
  import struct, sys
  
  class my_top_block(gr.top_block):
      def __init__(self, callback, options):
          gr.top_block.__init__(self)
  
          if(options.rx_freq is not None):
              self.source = uhd_receiver(options.args,
                                         options.bandwidth,
                                         options.rx_freq, options.rx_gain,
                                         options.spec, options.antenna,
                                         options.verbose)
          elif(options.from_file is not None):
              self.source = gr.file_source(gr.sizeof_gr_complex, options.from_file)
          else:
              self.source = gr.null_source(gr.sizeof_gr_complex)
  
          # Set up receive path
          # do this after for any adjustments to the options that may
          # occur in the sinks (specifically the UHD sink)
          self.rxpath = receive_path(callback, options)
  
          self.connect(self.source, self.rxpath)
          
  
  # /////////////////////////////////////////////////////////////////////////////
  #                                   main
  # /////////////////////////////////////////////////////////////////////////////
  
  def main():
  
      global n_rcvd, n_right
          
      n_rcvd = 0
      n_right = 0
  
      def rx_callback(ok, payload):
          global n_rcvd, n_right
          n_rcvd += 1
          (pktno,) = struct.unpack('!H', payload[0:2])
          if ok:
              n_right += 1
          print "ok: %r \t pktno: %d \t n_rcvd: %d \t n_right: %d" % (ok, pktno, n_rcvd, n_right)
  
          if 0:
              printlst = list()
              for x in payload[2:]:
                  t = hex(ord(x)).replace('0x', '')
                  if(len(t) == 1):
                      t = '0' + t
                  printlst.append(t)
              printable = ''.join(printlst)
  
              print printable
              print "\n"
  
      parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
      expert_grp = parser.add_option_group("Expert")
      parser.add_option("","--discontinuous", action="store_true", default=False,
                        help="enable discontinuous")
      parser.add_option("","--from-file", default=None,
                        help="input file of samples to demod")
  
      receive_path.add_options(parser, expert_grp)
      uhd_receiver.add_options(parser)
      digital.ofdm_demod.add_options(parser, expert_grp)
  
      (options, args) = parser.parse_args ()
  
      if options.from_file is None:
          if options.rx_freq is None:
              sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
              parser.print_help(sys.stderr)
              sys.exit(1)
  
      # build the graph
      tb = my_top_block(rx_callback, options)
  
      r = gr.enable_realtime_scheduling()
      if r != gr.RT_OK:
          print "Warning: failed to enable realtime scheduling"
  
      tb.start()                      # start flow graph
      tb.wait()                       # wait for it to finish
  
  if __name__ == '__main__':
      try:
          main()
      except KeyboardInterrupt:
          pass
  