Updated license from GPL version 2 or later to GPL version 3 or later.
[debian/gnuradio] / gr-sounder / src / python / sounder.py
1 #!/usr/bin/env python
2 #
3 # Copyright 2007 Free Software Foundation, Inc.
4
5 # This file is part of GNU Radio
6
7 # GNU Radio is free software; you can redistribute it and/or modify
8 # it under the terms of the GNU General Public License as published by
9 # the Free Software Foundation; either version 3, or (at your option)
10 # any later version.
11
12 # GNU Radio is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 # GNU General Public License for more details.
16
17 # You should have received a copy of the GNU General Public License
18 # along with GNU Radio; see the file COPYING.  If not, write to
19 # the Free Software Foundation, Inc., 51 Franklin Street,
20 # Boston, MA 02110-1301, USA.
21
22
23 from gnuradio import gr, usrp
24 from gnuradio import eng_notation
25
26 n2s = eng_notation.num_to_str
27
28 FR_MODE = usrp.FR_USER_0
29 bmFR_MODE_RESET = 1 << 0        # bit 0: active high reset
30 bmFR_MODE_TX    = 1 << 1        # bit 1: enable transmitter
31 bmFR_MODE_RX    = 1 << 2        # bit 2: enable receiver
32 bmFR_MODE_LP    = 1 << 3        # bit 3: enable digital loopback
33
34 FR_DEGREE = usrp.FR_USER_1
35 FR_AMPL = usrp.FR_USER_2
36
37 def pick_subdevice(u):
38     """
39     The user didn't specify a subdevice on the command line.
40     If there's a daughterboard on A, select A.
41     If there's a daughterboard on B, select B.
42     Otherwise, select A.
43     """
44     if u.db[0][0].dbid() >= 0:       # dbid is < 0 if there's no d'board or a problem
45         return (0, 0)
46     if u.db[1][0].dbid() >= 0:
47         return (1, 0)
48     return (0, 0)
49
50 class sounder_tx:
51     def __init__(self, loopback=False,ampl=4096,verbose=False,debug=False):
52         self._loopback=loopback
53         self._amplitude = ampl
54         self._verbose = verbose
55         self._debug = debug
56         self._u = usrp.sink_s(fpga_filename='usrp_sounder.rbf')
57         if not self._loopback:
58             self._subdev_spec = usrp.pick_tx_subdevice(self._u)
59             self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
60             if self._verbose:
61                 print "Using", self._subdev.name(), "for sounder transmitter."            
62         self.set_amplitude(ampl)
63         self._subdev.set_lo_offset(0.0)
64         self._u.start()
65         self._subdev.set_enable(True)
66             
67     def tune(self, frequency):
68         if self._verbose:
69             print "Setting transmitter frequency to", n2s(frequency)
70         result = self._u.tune(0, self._subdev, frequency)
71         if result == False:
72             raise RuntimeError("Failed to set transmitter frequency.")
73
74     def set_amplitude(self, ampl):
75         self._amplitude = ampl
76         if self._debug:
77             print "Writing amplitude register with:", hex(self._mode)
78         self._u._write_fpga_reg(FR_AMPL, self._amplitude)
79
80 class sounder_rx:
81     def __init__(self,subdev_spec=None,gain=None,length=1,alpha=1.0,msgq=None,loopback=False,verbose=False,debug=False):
82         self._subdev_spec = subdev_spec
83         self._gain = gain
84         self._length = length
85         self._alpha = alpha
86         self._msgq = msgq
87         self._loopback = loopback
88         self._verbose = verbose
89         self._debug = debug
90                 
91         self._fg = gr.flow_graph()
92         self._u = usrp.source_c(fpga_filename='usrp_sounder.rbf')
93         if not self._loopback:
94             if self._subdev_spec == None:
95                 self._subdev_spec = pick_subdevice(self._u)
96             self._u.set_mux(usrp.determine_rx_mux_value(self._u, self._subdev_spec))
97             self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
98             if self._verbose:
99                 print "Using", self._subdev.name(), "for sounder receiver."
100
101         self.set_gain(self._gain)
102         self._vblen = gr.sizeof_gr_complex*self._length
103         if self._debug:
104             print "Generating impulse vectors of length", self._length, "byte length", self._vblen
105             
106         self._s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self._length)
107         if self._verbose:
108             print "Using smoothing alpha of", self._alpha
109         self._lpf = gr.single_pole_iir_filter_cc(self._alpha, self._length)
110         self._sink = gr.message_sink(self._vblen, self._msgq, True)
111         self._fg.connect(self._u, self._s2v, self._lpf, self._sink)
112
113     def tune(self, frequency):
114         if self._verbose:
115             print "Setting receiver frequency to", n2s(frequency)
116         result = self._u.tune(0, self._subdev, frequency)
117         if result == False:
118             raise RuntimeError("Failed to set receiver frequency.")
119
120     def set_gain(self, gain):
121         self._gain = gain
122         if self._loopback:
123             return
124             
125         if self._gain is None:
126             # if no gain was specified, use the mid-point in dB
127             g = self._subdev.gain_range()
128             self._gain = float(g[0]+g[1])/2
129         if self._verbose:
130             print "Setting receiver gain to", gain
131         self._subdev.set_gain(self._gain)
132
133     def start(self):
134         if self._debug:
135             print "Starting receiver flow graph."
136         self._fg.start()
137
138     def wait(self):
139         if self._debug:
140             print "Waiting for threads..."
141         self._fg.wait()
142
143     def stop(self):
144         if self._debug:
145             print "Stopping receiver flow graph."
146         self._fg.stop()
147         self.wait()
148         if self._debug:
149             print "Receiver flow graph stopped."
150
151
152 class sounder:
153     def __init__(self,transmit=False,receive=False,loopback=False,rx_subdev_spec=None,ampl=0x1FFF,
154                  frequency=0.0,rx_gain=None,degree=12,length=1,alpha=1.0,msgq=None,verbose=False,debug=False):
155         self._transmit = transmit
156         self._receive = receive
157         self._loopback = loopback
158         self._rx_subdev_spec = rx_subdev_spec
159         self._frequency = frequency
160         self._amplitude = ampl
161         self._rx_gain = rx_gain
162         self._degree = degree
163         self._length = length
164         self._alpha = alpha
165         self._msgq = msgq
166         self._verbose = verbose
167         self._debug = debug
168         self._mode = 0
169         self._u = None
170         self._trans = None
171         self._rcvr = None
172         self._transmitting = False
173         self._receiving = False
174                 
175         if self._transmit:
176             self._trans = sounder_tx(loopback=self._loopback,ampl=self._amplitude,
177                                      verbose=self._verbose)
178             self._u = self._trans._u
179             
180         if self._receive:
181             self._rcvr = sounder_rx(subdev_spec=self._rx_subdev_spec,length=self._length,
182                                     gain=self._rx_gain,alpha=self._alpha,msgq=self._msgq,
183                                     loopback=self._loopback,verbose=self._verbose, 
184                                     debug=self._debug)
185             self._u = self._rcvr._u # either receiver or transmitter object will do
186         
187         self.set_reset(True)
188         if self._loopback == False:
189             self.tune(self._frequency)
190         self.set_degree(self._degree)
191         self.set_loopback(self._loopback)       
192         self.set_reset(False)
193                 
194     def tune(self, frequency):
195         self._frequency = frequency
196         if self._rcvr:
197             self._rcvr.tune(frequency)
198         if self._trans:
199             self._trans.tune(frequency)
200
201     def set_degree(self, degree):
202         if self._verbose:
203             print "Setting PN code degree to", degree
204         self._u._write_fpga_reg(FR_DEGREE, degree);
205             
206     def _write_mode(self):
207         if self._debug:
208             print "Writing mode register with:", hex(self._mode)
209         self._u._write_fpga_reg(FR_MODE, self._mode)
210
211     def enable_tx(self, value):
212         if value:
213             if self._verbose:
214                 print "Enabling transmitter."
215             self._mode |= bmFR_MODE_TX
216             self._transmitting = True
217         else:
218             if self._verbose:
219                 print "Disabling transmitter."
220             self._mode &= ~bmFR_MODE_TX
221         self._write_mode()
222                     
223     def enable_rx(self, value):
224         if value:
225             self._mode |= bmFR_MODE_RX
226             self._write_mode()
227             self._rcvr.start()
228             self._receiving = True
229         else:
230             self._rcvr.stop()
231             self._mode &= ~bmFR_MODE_RX
232             self._write_mode()
233             self._receiving = False
234                 
235     def set_loopback(self, value):
236         if value:
237             if self._verbose:
238                 print "Enabling digital loopback."
239             self._mode |= bmFR_MODE_LP
240         else:
241             if self._verbose:
242                 print "Disabling digital loopback."
243             self._mode &= ~bmFR_MODE_LP
244         self._write_mode()
245
246     def set_reset(self, value):
247         if value:
248             if self._debug:
249                 print "Asserting reset."
250             self._mode |= bmFR_MODE_RESET
251         else:
252             if self._debug:
253                 print "De-asserting reset."
254             self._mode &= ~bmFR_MODE_RESET
255         self._write_mode()
256
257     def start(self):
258         if self._transmit:
259             self.enable_tx(True)
260         if self._receive:
261             self.enable_rx(True)
262
263     def __del__(self):
264         if self._transmitting:
265             self.enable_tx(False)
266             
267         if self._receiving:
268             self.enable_rx(False)
269