git.gag.com Git - debian/gnuradio/blob - gnuradio-examples/python/multi_usrp/multi_usrp_rx_cfile.py

   1 #!/usr/bin/env python
   2
   3 """
   4 Read samples 2 from two linked synchronised USRP's and write to file formatted as binary
   5 single-precision complex values.
   6 Make sure you read README on how to link the two usrps
   7
   8 """
   9
  10 from gnuradio import gr, eng_notation
  11 from gnuradio import audio
  12 from gnuradio import usrp
  13 from gnuradio.eng_option import eng_option
  14 from optparse import OptionParser
  15 import sys
  16
  17 import time
  18 from gnuradio import usrp_multi
  19
  20 class my_graph(gr.flow_graph):
  21
  22     def __init__(self):
  23         gr.flow_graph.__init__(self)
  24
  25         usage="%prog: [options] output_filename"
  26         parser = OptionParser(option_class=eng_option, usage=usage)
  27         parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0, 0),
  28                           help="select USRP Rx side A or B (default=A)")
  29         parser.add_option("-d", "--decim", type="int", default=128,
  30                           help="set selfpa decimation rate to DECIM [default=%default]")
  31         parser.add_option("-f", "--freq", type="eng_float", default=0.0,
  32                           help="set frequency to FREQ", metavar="FREQ")
  33         parser.add_option("-g", "--gain", type="eng_float", default=None,
  34                           help="set gain in dB (default is midpoint)")
  35         parser.add_option("-n", "--nchan", type="intx", default=2,
  36                           help="set nchannels to NCHAN")
  37         parser.add_option("-N", "--nsamples", type="eng_float", default=None,
  38                           help="number of samples to collect [default=+inf]")
  39         parser.add_option ("-o", "--output-file-m", default="usrp_rx_m.dat",
  40                        help="write master data to FILE", metavar="FILE")
  41         parser.add_option ("--output-file-m2", default="usrp_rx_m2.dat",
  42                        help="write master data from second channel to FILE", metavar="FILE")
  43         parser.add_option ("-p", "--output-file-s", default="usrp_rx_s.dat",
  44                        help="write slave data to FILE", metavar="FILE")
  45         parser.add_option ("--output-file-s2", default="usrp_rx_s2.dat",
  46                        help="write slave data from second channel to FILE", metavar="FILE")
  47         parser.add_option("-x", "--master-serialno", type="string", default=None,
  48                           help="Serial_no of the usrp which should be the MASTER (default= select any)")
  49         (options, args) = parser.parse_args ()
  50         if len(args) != 0:
  51             parser.print_help()
  52             raise SystemExit, 1
  53
  54         if options.freq is None:
  55             parser.print_help()
  56             sys.stderr.write('You must specify the frequency with -f FREQ\n');
  57             raise SystemExit, 1
  58
  59         # build the graph
  60         self.multi=usrp_multi.multi_source_align( fg=self, master_serialno=options.master_serialno, decim=options.decim,
  61                                                   nchan=options.nchan )
  62         self.um=self.multi.get_master_usrp()
  63         self.us=self.multi.get_slave_usrp()
  64
  65         dst_m=gr.file_sink (gr.sizeof_gr_complex, options.output_file_m)
  66         dst_s=gr.file_sink (gr.sizeof_gr_complex, options.output_file_s)
  67         if options.nsamples is None:
  68             self.connect((self.multi.get_master_source_c(),1),dst_m)
  69             self.connect((self.multi.get_slave_source_c(),1),dst_s)
  70         else:
  71             head_m = gr.head(gr.sizeof_gr_complex, int(options.nsamples))
  72             head_s = gr.head(gr.sizeof_gr_complex, int(options.nsamples))
  73             self.connect((self.multi.get_master_source_c(),1),head_m,dst_m)
  74             self.connect((self.multi.get_slave_source_c(),1),head_s,dst_s)
  75
  76         if(4==options.nchan):
  77             dst_m2=gr.file_sink (gr.sizeof_gr_complex, options.output_file_m2)
  78             dst_s2=gr.file_sink (gr.sizeof_gr_complex, options.output_file_s2)
  79             if options.nsamples is None:
  80                 self.connect((self.multi.get_master_source_c(),2),dst_m2)
  81                 self.connect((self.multi.get_slave_source_c(),2),dst_s2)
  82             else:
  83                 head_m2 = gr.head(gr.sizeof_gr_complex, int(options.nsamples))
  84                 head_s2 = gr.head(gr.sizeof_gr_complex, int(options.nsamples))
  85                 self.connect((self.multi.get_master_source_c(),2),head_m2,dst_m2)
  86                 self.connect((self.multi.get_slave_source_c(),2),head_s2,dst_s2)
  87
  88         if options.rx_subdev_spec is None:
  89             options.rx_subdev_spec = usrp.pick_rx_subdevice(self.um)
  90
  91         if (options.nchan!=4):
  92           mux=usrp.determine_rx_mux_value(self.um, options.rx_subdev_spec)
  93           mux= (mux<<8 & 0xffffffff) | (mux & 0xff)
  94           self.um.set_mux(mux)
  95           self.us.set_mux(mux)
  96
  97         # determine the daughterboard subdevice we're using
  98         self.subdevm = usrp.selected_subdev(self.um, options.rx_subdev_spec)
  99         self.subdevs = usrp.selected_subdev(self.us, options.rx_subdev_spec)
 100         print "Using MASTER RX d'board %s" % (self.subdevm.side_and_name(),)
 101         print "Using SLAVE RX d'board %s" % (self.subdevs.side_and_name(),)
 102         input_rate = self.um.adc_freq() / self.um.decim_rate()
 103         print "USB sample rate %s" % (eng_notation.num_to_str(input_rate))
 104
 105         if options.gain is None:
 106             # if no gain was specified, use the mid-point in dB
 107             g = self.subdevm.gain_range()
 108             options.gain = float(g[0]+g[1])/2
 109
 110         self.multi.set_gain_all_rx(options.gain)
 111         result,r1,r2,r3,r4 = self.multi.tune_all_rx(options.freq)
 112         if not result:
 113             sys.stderr.write('Failed to set frequency\n')
 114             raise SystemExit, 1
 115
 116     def sync_usrps(self):
 117         self.multi.sync()
 118
 119
 120 if __name__ == '__main__':
 121     fg=my_graph()
 122     fg.start()
 123     #time.sleep(0.5)
 124     fg.sync_usrps()
 125     raw_input ('Press Enter to quit: ')
 126     fg.stop()
 127     #try:
 128     #    fg.start()
 129     #    fg.sync_usrps()
 130     #except KeyboardInterrupt:
 131     #    pass