← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gnuradio/trusty-updates

« back to all changes in this revision

Viewing changes to gr-uhd/apps/hf_radio/radio.py

  • Committer: Package Import Robot
  • Author(s): A. Maitland Bottoms
  • Date: 2012-02-26 21:26:16 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20120226212616-vsfkbi1158xshdql
Tags: 3.5.1-1
http://bugs.debian.org/642716
http://bugs.debian.org/645332
http://bugs.debian.org/394849
http://bugs.debian.org/616832
http://bugs.debian.org/590048
http://bugs.debian.org/642580
* new upstream version, re-packaged from scratch with modern tools
    closes: #642716, #645332, #394849, #616832, #590048, #642580,
    #647018, #557050, #559640, #631863
* CMake build

Show diffs side-by-side

added added

removed removed

Lines of Context:
gr-uhd/apps/hf_radio/radio.py
 
1
#!/usr/bin/env python
 
2
#
 
3
# Copyright 2011 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
# GUI interactions and high level connections handled here.
 
24
#
 
25
# Interacts with classes defined by wxGlade in ui.py.
 
26
#
 
27
# M. Revnell 2006-Jan
 
28
 
 
29
from threading import *
 
30
import wx
 
31
import wx.lib.evtmgr as em
 
32
import time
 
33
 
 
34
from gnuradio import gr, gru, eng_notation, optfir
 
35
from gnuradio import audio
 
36
from gnuradio import uhd
 
37
from gnuradio import blks2
 
38
from gnuradio.wxgui import fftsink2
 
39
from gnuradio.wxgui import waterfallsink2
 
40
from gnuradio.wxgui import scopesink2
 
41
 
 
42
from input    import *
 
43
from output   import *
 
44
from ssbdemod import *
 
45
from ssbagc   import *
 
46
from ui       import *
 
47
from math     import log10
 
48
 
 
49
class radio_top_block( gr.top_block ):
 
50
    def __init__( self ):
 
51
        gr.top_block.__init__(self, "radio_top_block")
 
52
 
 
53
        self.address      = "addr=192.168.11.2"
 
54
        self.samp_rate    = 256e3
 
55
        self.freq         = -2.5e6
 
56
        self.gain         = 0
 
57
        self.src          = uhd_input( self.address,
 
58
                                       self.samp_rate)
 
59
        self.src.set_freq(self.freq)
 
60
        self.src.set_gain(self.gain)
 
61
 
 
62
        self.fe_rate      = self.src.usrp_rate
 
63
        self.filter_decim = 1
 
64
        self.audio_decim  = 16
 
65
        self.demod_rate   = self.fe_rate / self.filter_decim
 
66
        self.audio_rate   = self.demod_rate / self.audio_decim
 
67
        self.audio_dev    = "pulse"
 
68
 
 
69
        self.demod        = ssb_demod( self.demod_rate, self.audio_rate )
 
70
        self.agc          = agc()
 
71
        self.out          = output( self.audio_rate, self.audio_dev )
 
72
 
 
73
        self.connect( self.src, self.demod, self.agc, self.out )
 
74
 
 
75
    def tune( self, freq ):
 
76
        fe_target = -freq
 
77
        self.src.set_freq( fe_target )
 
78
        demod_cf = fe_target - self.src.get_freq()
 
79
        self.demod.tune( demod_cf )
 
80
 
 
81
class radio_frame( ui_frame ):
 
82
    def __init__( self, block, *args, **kwds ):
 
83
        ui_frame.__init__( self, *args, **kwds )
 
84
        self.block = block
 
85
        self.freq_disp.SetRange(0, 30e6)
 
86
        f = self.block.src.freq
 
87
        self.freq_disp.SetValue( -f )
 
88
        self.volume.SetRange( 0, 20 )
 
89
        self.pga.SetRange( 0, 20 )
 
90
        self.rssi_range = 1
 
91
        self.rssi.SetRange( self.rssi_range )
 
92
        self.agc_max.SetValue( str( self.rssi_range ) )
 
93
        self.spin_e0.SetValue( 50 )
 
94
        self.spin_e1.SetValue( 50 )
 
95
        self.spin_e2.SetValue( 50 )
 
96
        self.spin_e3.SetValue( 50 )
 
97
        self.spin_e4.SetValue( 50 )
 
98
        self.spin_e5.SetValue( 50 )
 
99
        self.spin_e6.SetValue( 50 )
 
100
        bw = 3.3e3
 
101
        self.bandwidth.SetValue( str( bw ) )
 
102
        self.block.demod.set_bw( bw )
 
103
        self.bw_spin.SetValue( 5 )
 
104
        agc_gain = self.block.agc.gain.k()
 
105
        self.agc_gain_s.SetValue( 5 )
 
106
        self.agc_gain.SetValue( str( agc_gain ) )
 
107
        agc_ref = self.block.agc.offs.k()
 
108
        self.agc_ref.SetValue( str( agc_ref ) )
 
109
        self.agc_ref_s.SetValue( 5 )
 
110
        
 
111
        self.fespectrum = fftsink2.fft_sink_c(
 
112
            self.fe_panel,
 
113
            fft_size=512,
 
114
            sample_rate = block.fe_rate,
 
115
            ref_scale = 1.0,
 
116
            ref_level = 20.0,
 
117
            y_divs = 12,
 
118
            avg_alpha = 0.1)
 
119
 
 
120
        self.ifspectrum = fftsink2.fft_sink_c(
 
121
            self.if_panel,
 
122
            fft_size=512,
 
123
            sample_rate = block.audio_rate,
 
124
            ref_scale = 1.0,
 
125
            ref_level = 20.0,
 
126
            y_divs = 12,
 
127
            avg_alpha = 0.1)
 
128
 
 
129
        self.fespectrum.win.Bind( wx.EVT_MOTION, self.fe_mouse)
 
130
        self.fespectrum.win.Bind( wx.EVT_LEFT_DOWN, self.fe_click)
 
131
 
 
132
        block.connect( block.src.src, self.fespectrum )
 
133
        block.connect( block.demod.xlate, self.ifspectrum )
 
134
 
 
135
    def agc_ref_up( self, event ):
 
136
        self.agc_ref_s.SetValue( 5 )
 
137
        r = float( self.agc_ref.GetValue() )
 
138
        r = r + 5
 
139
        self.agc_ref.SetValue( str( r ) )
 
140
        self.block.agc.offs.set_k( r )
 
141
        
 
142
    def agc_ref_down( self, event ):
 
143
        self.agc_ref_s.SetValue( 5 )
 
144
        r = float( self.agc_ref.GetValue() )
 
145
        r = r - 5
 
146
        self.agc_ref.SetValue( str( r ) )
 
147
        self.block.agc.offs.set_k( r )
 
148
 
 
149
    def agc_gain_up( self, event ):
 
150
        self.agc_gain_s.SetValue( 5 )
 
151
        g = float(self.agc_gain.GetValue())
 
152
        g = g + 10
 
153
        self.agc_gain.SetValue( str( g ) )
 
154
        self.block.agc.gain.set_k( g )
 
155
 
 
156
    def agc_gain_down( self, event ):
 
157
        self.agc_gain_s.SetValue( 5 )
 
158
        g = float(self.agc_gain.GetValue())
 
159
        g = g - 10
 
160
        self.agc_gain.SetValue( str( g ) )
 
161
        self.block.agc.gain.set_k( g )
 
162
 
 
163
    def fe_mouse( self, event ):
 
164
        f = int(self.freq_disp.GetValue())
 
165
        f = f+((event.GetX()-346.)*(400./610.))*1000
 
166
        self.fespectrum.win.SetToolTip(
 
167
            wx.ToolTip( eng_notation.num_to_str(f)))
 
168
 
 
169
    def fe_click( self, event ):
 
170
        f = int(self.freq_disp.GetValue())
 
171
        f = f+((event.GetX()-346.)*(400./610.))*1000
 
172
        self.tune( f )
 
173
 
 
174
    def setrssi( self, level ):
 
175
        if level < 0:
 
176
            level = 0
 
177
        if level > self.rssi_range:
 
178
            self.rssi_range = level
 
179
            self.rssi.SetRange( level )
 
180
            self.agc_max.SetValue( str( level ))
 
181
        self.rssi.SetValue( level )
 
182
        self.agc_level.SetValue( str( level ))
 
183
 
 
184
    def tune_evt( self, event ):
 
185
        f = self.freq_disp.GetValue()
 
186
        self.tune( f )
 
187
        
 
188
    def tune( self, frequency ):
 
189
        self.freq_disp.SetValue( frequency )
 
190
        self.block.tune( frequency )
 
191
 
 
192
    def up_e0( self, event ):
 
193
        self.spin_e0.SetValue( 50 )
 
194
        self.tune( self.freq_disp.GetValue() + 1e0 )
 
195
 
 
196
    def down_e0( self, event ):
 
197
        self.spin_e0.SetValue( 50 )
 
198
        self.tune( self.freq_disp.GetValue() - 1e0 )
 
199
 
 
200
    def up_e1( self, event ):
 
201
        self.spin_e1.SetValue( 50 )
 
202
        self.tune( self.freq_disp.GetValue() + 1e1 )
 
203
 
 
204
    def down_e1( self, event ):
 
205
        self.spin_e1.SetValue( 50 )
 
206
        self.tune( self.freq_disp.GetValue() - 1e1 )
 
207
 
 
208
    def up_e2( self, event ):
 
209
        self.spin_e2.SetValue( 50 )
 
210
        self.tune( self.freq_disp.GetValue() + 1e2 )
 
211
 
 
212
    def down_e2( self, event ):
 
213
        self.spin_e2.SetValue( 50 )
 
214
        self.tune( self.freq_disp.GetValue() - 1e2 )
 
215
 
 
216
    def up_e3( self, event ):
 
217
        self.spin_e3.SetValue( 50 )
 
218
        self.tune( self.freq_disp.GetValue() + 1e3 )
 
219
 
 
220
    def down_e3( self, event ):
 
221
        self.spin_e3.SetValue( 50 )
 
222
        self.tune( self.freq_disp.GetValue() - 1e3 )
 
223
 
 
224
    def up_e4( self, event ):
 
225
        self.spin_e4.SetValue( 50 )
 
226
        self.tune( self.freq_disp.GetValue() + 1e4 )
 
227
 
 
228
    def down_e4( self, event ):
 
229
        self.spin_e4.SetValue( 50 )
 
230
        self.tune( self.freq_disp.GetValue() - 1e4 )
 
231
 
 
232
    def up_e5( self, event ):
 
233
        self.spin_e5.SetValue( 50 )
 
234
        self.tune( self.freq_disp.GetValue() + 1e5 )
 
235
 
 
236
    def down_e5( self, event ):
 
237
        self.spin_e5.SetValue( 50 )
 
238
        self.tune( self.freq_disp.GetValue() - 1e5 )
 
239
 
 
240
    def up_e6( self, event ):
 
241
        self.spin_e6.SetValue( 50 )
 
242
        self.tune( self.freq_disp.GetValue() + 1e6 )
 
243
 
 
244
    def down_e6( self, event ):
 
245
        self.spin_e6.SetValue( 50 )
 
246
        self.tune( self.freq_disp.GetValue() - 1e6 )
 
247
 
 
248
    def event_pga( self, event ):
 
249
        self.block.src.set_gain(self.pga.GetValue())
 
250
        
 
251
    def event_vol( self, event ):
 
252
        self.block.out.set( self.volume.GetValue()/20.0 )
 
253
 
 
254
    def set_usb( self, event ):
 
255
        self.block.demod.upper_sb()
 
256
        
 
257
    def set_lsb( self, event ):
 
258
        self.block.demod.lower_sb()
 
259
 
 
260
    def set_am( self, event ):
 
261
        self.block.demod.set_am()
 
262
 
 
263
    def bw_up( self, event ):
 
264
        self.bw_spin.SetValue( 5 )
 
265
        bw = float(self.bandwidth.GetValue())
 
266
        bw = bw + 20.0
 
267
        if bw > 10e3:
 
268
            bw = 10e3
 
269
        self.bandwidth.SetValue( str( bw ) )
 
270
        self.block.demod.set_bw( bw )
 
271
 
 
272
    def bw_down( self, event ):
 
273
        self.bw_spin.SetValue( 5 )
 
274
        bw = float(self.bandwidth.GetValue())
 
275
        bw = bw - 20.0
 
276
        if bw < 50:
 
277
            bw = 50
 
278
        self.bandwidth.SetValue( str( bw ) )
 
279
        self.block.demod.set_bw( bw )
 
280
 
 
281
 
 
282
class radio( wx.App ):
 
283
    def OnInit( self ):
 
284
        self.block = radio_top_block()
 
285
        self.frame = radio_frame( self.block, None, -1, "HF Receiver" )
 
286
        self.frame.Show( True )
 
287
        self.SetTopWindow( self.frame )
 
288
        self.block.start()
 
289
        return True
 
290
 
 
291
def rssi_function():
 
292
    global radio_obj
 
293
    global sig_probe
 
294
 
 
295
    go = True
 
296
    while go:
 
297
        try:
 
298
            level = sig_probe.level()
 
299
            wx.CallAfter( radio_obj.frame.setrssi, level )
 
300
            time.sleep( .1 )
 
301
        except:
 
302
            go = False
 
303
 
 
304
def main():
 
305
    global radio_obj, sig_probe
 
306
 
 
307
    radio_obj = radio( 0 )
 
308
    sig_probe = gr.probe_signal_f()
 
309
    radio_obj.block.connect(radio_obj.block.agc.offs, sig_probe)
 
310
 
 
311
    thread2 = Thread( target = rssi_function )
 
312
    thread2.start()
 
313
      
 
314
    radio_obj.MainLoop()
 
315
    
 
316
 
 
317
if __name__ == "__main__":
 
318
    main()
 
319