def __init__(self,frame,panel,vbox,argv):
stdgui2.std_top_block.__init__ (self,frame,panel,vbox,argv)
usage="%prog: [options] [input_filename]. \n If you don't specify an input filename the usrp will be used as source\n " \
"Make sure your input capture file containes interleaved shorts not complex floats"
parser=OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-a", "--args", type="string", default="",
help="UHD device address args [default=%default]")
parser.add_option("", "--spec", type="string", default=None,
help="Subdevice of UHD device where appropriate")
parser.add_option("-A", "--antenna", type="string", default=None,
help="select Rx Antenna where appropriate")
parser.add_option("-s", "--samp-rate", type="eng_float", default=1e6,
help="set sample rate")
parser.add_option("-f", "--freq", type="eng_float", default=519.25e6,
help="set frequency to FREQ", metavar="FREQ")
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("-c", "--contrast", type="eng_float", default=1.0,
help="set contrast (default is 1.0)")
parser.add_option("-b", "--brightness", type="eng_float", default=0.0,
help="set brightness (default is 0)")
parser.add_option("-p", "--pal", action="store_true", default=False,
help="PAL video format (this is the default)")
parser.add_option("-n", "--ntsc", action="store_true", default=False,
help="NTSC video format")
parser.add_option("-o", "--out-filename", type="string", default="sdl",
help="For example out_raw_uchar.gray. If you don't specify an output filename you will get a video_sink_sdl realtime output window. You then need to have gr-video-sdl installed)")
parser.add_option("-r", "--repeat", action="store_false", default=True,
help="repeat file in a loop")
parser.add_option("", "--freq-min", type="eng_float", default=50.25e6,
help="Set a minimum frequency [default=%default]")
parser.add_option("", "--freq-max", type="eng_float", default=900.25e6,
help="Set a maximum frequency [default=%default]")
(options, args) = parser.parse_args()
if not ((len(args) == 1) or (len(args) == 0)):
parser.print_help()
sys.exit(1)
if len(args) == 1:
filename = args[0]
else:
filename = None
self.frame = frame
self.panel = panel
self.contrast = options.contrast
self.brightness = options.brightness
self.state = "FREQ"
self.freq = 0
self.tv_freq_min = options.freq_min
self.tv_freq_max = options.freq_max
# build graph
self.u=None
if not (options.out_filename=="sdl"):
options.repeat=False
usrp_rate = options.samp_rate
if not ((filename is None) or (filename=="usrp")):
# file is data source
self.filesource = gr.file_source(gr.sizeof_short,filename,options.repeat)
self.istoc = gr.interleaved_short_to_complex()
self.connect(self.filesource,self.istoc)
self.src=self.istoc
options.gain=0.0
self.gain=0.0
else: # use a UHD device
self.u = uhd.usrp_source(device_addr=options.args, stream_args=uhd.stream_args('fc32'))
# Set the subdevice spec
if(options.spec):
self.u.set_subdev_spec(options.spec, 0)
# Set the antenna
if(options.antenna):
self.u.set_antenna(options.antenna, 0)
self.u.set_samp_rate(usrp_rate)
dev_rate = self.u.get_samp_rate()
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.get_gain_range()
options.gain = float(g.start()+g.stop())/2.0
self.src=self.u
self.gain = options.gain
f2uc=gr.float_to_uchar()
# sdl window as final sink
if not (options.pal or options.ntsc):
options.pal=True #set default to PAL
if options.pal:
lines_per_frame=625.0
frames_per_sec=25.0
show_width=768
elif options.ntsc:
lines_per_frame=525.0
frames_per_sec=29.97002997
show_width=640
width=int(usrp_rate/(lines_per_frame*frames_per_sec))
height=int(lines_per_frame)
if (options.out_filename=="sdl"):
#Here comes the tv screen, you have to build and install
#gr-video-sdl for this (subproject of gnuradio, only in cvs
#for now)
try:
video_sink = video_sdl.sink_uc ( frames_per_sec, width, height, 0,
show_width, height)
except:
print "gr-video-sdl is not installed"
print "realtime \"sdl\" video output window is not available"
raise SystemExit, 1
self.dst=video_sink
else:
print "You can use the imagemagick display tool to show the resulting imagesequence"
print "use the following line to show the demodulated TV-signal:"
print "display -depth 8 -size " +str(width)+ "x" + str(height) \
+ " gray:" + options.out_filename
print "(Use the spacebar to advance to next frames)"
options.repeat=False
file_sink=gr.file_sink(gr.sizeof_char, options.out_filename)
self.dst =file_sink
self.agc=gr.agc_cc(1e-7,1.0,1.0) #1e-7
self.am_demod = gr.complex_to_mag ()
self.set_blacklevel=gr.add_const_ff(0.0)
self.invert_and_scale = gr.multiply_const_ff (0.0) #-self.contrast *128.0*255.0/(200.0)
# now wire it all together
#sample_rate=options.width*options.height*options.framerate
process_type='do_no_sync'
if process_type=='do_no_sync':
self.connect (self.src, self.agc,self.am_demod,
self.invert_and_scale, self.set_blacklevel,
f2uc,self.dst)
elif process_type=='do_tv_sync_adv':
#defaults: gr.tv_sync_adv (double sampling_freq, unsigned
#int tv_format,bool output_active_video_only=false, bool
#do_invert=false, double wanted_black_level=0.0, double
#wanted_white_level=255.0, double avg_alpha=0.1, double
#initial_gain=1.0, double initial_offset=0.0,bool
#debug=false)
#note, this block is not yet in cvs
self.tv_sync_adv=gr.tv_sync_adv(usrp_rate, 0, False, False,
0.0, 255.0, 0.01, 1.0, 0.0, False)
self.connect (self.src, self.am_demod, self.invert_and_scale,
self.tv_sync_adv, s2f, f2uc, self.dst)
elif process_type=='do_nullsink':
#self.connect (self.src, self.am_demod,self.invert_and_scale,f2uc,video_sink)
c2r=gr.complex_to_real()
nullsink=gr.null_sink(gr.sizeof_float)
self.connect (self.src, c2r,nullsink) #video_sink)
elif process_type=='do_tv_sync_corr':
frame_size=width*height #int(usrp_rate/25.0)
nframes=10# 32
search_window=20*nframes
debug=False
video_alpha=0.3 #0.1
corr_alpha=0.3
#Note: this block is not yet in cvs
tv_corr=gr.tv_correlator_ff(frame_size,nframes, search_window,
video_alpha, corr_alpha,debug)
shift=gr.add_const_ff(-0.7)
self.connect (self.src, self.agc, self.am_demod, tv_corr,
self.invert_and_scale, self.set_blacklevel,
f2uc, self.dst)
else: # process_type=='do_test_image':
src_vertical_bars = gr.sig_source_f (usrp_rate, gr.GR_SIN_WAVE,
10.0 *usrp_rate/320, 255,128)
self.connect(src_vertical_bars, f2uc, self.dst)
self._build_gui(vbox, usrp_rate, usrp_rate, usrp_rate)
frange = self.u.get_freq_range()
if(frange.start() > self.tv_freq_max or frange.stop() < self.tv_freq_min):
sys.stderr.write("Radio does not support required frequency range.\n")
sys.exit(1)
if(options.freq < self.tv_freq_min or options.freq > self.tv_freq_max):
sys.stderr.write("Requested frequency is outside of required frequency range.\n")
sys.exit(1)
# set initial values
self.set_gain(options.gain)
self.set_contrast(self.contrast)
self.set_brightness(options.brightness)
if not(self.set_freq(options.freq)):
self._set_status_msg("Failed to set initial frequency")
def __init__(self):
gr.top_block.__init__(self)
usage=("%prog: [options] output_filename.\nSpecial output_filename" + \
"\"sdl\" will use video_sink_sdl as realtime output window. " + \
"You then need to have gr-video-sdl installed.\n" +\
"Make sure your input capture file containes interleaved " + \
"shorts not complex floats")
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-a",
"--args",
type="string",
default="",
help="UHD device address args [default=%default]")
parser.add_option("",
"--spec",
type="string",
default=None,
help="Subdevice of UHD device where appropriate")
parser.add_option("-A",
"--antenna",
type="string",
default=None,
help="select Rx Antenna where appropriate")
parser.add_option("-s",
"--samp-rate",
type="eng_float",
default=1e6,
help="set sample rate")
parser.add_option("-c",
"--contrast",
type="eng_float",
default=1.0,
help="set contrast (default is 1.0)")
parser.add_option("-b",
"--brightness",
type="eng_float",
default=0.0,
help="set brightness (default is 0)")
parser.add_option("-i", "--in-filename", type="string", default=None,
help="Use input file as source. samples must be " + \
"interleaved shorts \n Use usrp_rx_file.py or " + \
"usrp_rx_cfile.py --output-shorts.\n Special " + \
"name \"usrp\" results in realtime capturing " + \
"and processing using usrp.\n" + \
"You then probably need a decimation factor of 64 or higher.")
parser.add_option(
"-f",
"--freq",
type="eng_float",
default=519.25e6,
help=
"set frequency to FREQ.\nNote that the frequency of the video carrier is not at the middle of the TV channel",
metavar="FREQ")
parser.add_option("-g",
"--gain",
type="eng_float",
default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("-p",
"--pal",
action="store_true",
default=False,
help="PAL video format (this is the default)")
parser.add_option("-n",
"--ntsc",
action="store_true",
default=False,
help="NTSC video format")
parser.add_option("-r",
"--repeat",
action="store_false",
default=True,
help="repeat in_file in a loop")
parser.add_option("-N",
"--nframes",
type="eng_float",
default=None,
help="number of frames to collect [default=+inf]")
parser.add_option("",
"--freq-min",
type="eng_float",
default=50.25e6,
help="Set a minimum frequency [default=%default]")
parser.add_option("",
"--freq-max",
type="eng_float",
default=900.25e6,
help="Set a maximum frequency [default=%default]")
(options, args) = parser.parse_args()
if not (len(args) == 1):
parser.print_help()
sys.stderr.write('You must specify the output. FILENAME or sdl \n')
sys.exit(1)
filename = args[0]
self.tv_freq_min = options.freq_min
self.tv_freq_max = options.freq_max
if options.in_filename is None:
parser.print_help()
sys.stderr.write(
'You must specify the input -i FILENAME or -i usrp\n')
raise SystemExit, 1
if not (filename == "sdl"):
options.repeat = False
input_rate = options.samp_rate
print "video sample rate %s" % (eng_notation.num_to_str(input_rate))
if not (options.in_filename == "usrp"):
# file is data source, capture with usr_rx_csfile.py
self.filesource = blocks.file_source(gr.sizeof_short,
options.in_filename,
options.repeat)
self.istoc = blocks.interleaved_short_to_complex()
self.connect(self.filesource, self.istoc)
self.src = self.istoc
else:
if options.freq is None:
parser.print_help()
sys.stderr.write(
'You must specify the frequency with -f FREQ\n')
raise SystemExit, 1
# build the graph
self.u = uhd.usrp_source(device_addr=options.args,
stream_args=uhd.stream_args('fc32'))
# Set the subdevice spec
if (options.spec):
self.u.set_subdev_spec(options.spec, 0)
# Set the antenna
if (options.antenna):
self.u.set_antenna(options.antenna, 0)
self.u.set_samp_rate(input_rate)
dev_rate = self.u.get_samp_rate()
self.src = self.u
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.get_gain_range()
options.gain = float(g.start() + g.stop()) / 2.0
self.u.set_gain(options.gain)
r = self.u.set_center_freq(options.freq)
if not r:
sys.stderr.write('Failed to set frequency\n')
raise SystemExit, 1
self.agc = analog.agc_cc(1e-7, 1.0, 1.0) #1e-7
self.am_demod = blocks.complex_to_mag()
self.set_blacklevel = blocks.add_const_ff(options.brightness + 255.0)
self.invert_and_scale = blocks.multiply_const_ff(
-options.contrast * 128.0 * 255.0 / (200.0))
self.f2uc = blocks.float_to_uchar()
# sdl window as final sink
if not (options.pal or options.ntsc):
options.pal = True #set default to PAL
if options.pal:
lines_per_frame = 625.0
frames_per_sec = 25.0
show_width = 768
elif options.ntsc:
lines_per_frame = 525.0
frames_per_sec = 29.97002997
show_width = 640
width = int(input_rate / (lines_per_frame * frames_per_sec))
height = int(lines_per_frame)
if filename == "sdl":
#Here comes the tv screen, you have to build and install
#gr-video-sdl for this (subproject of gnuradio)
try:
video_sink = video_sdl.sink_uc(frames_per_sec, width, height,
0, show_width, height)
except:
print "gr-video-sdl is not installed"
print "realtime \"sdl\" video output window is not available"
raise SystemExit, 1
self.dst = video_sink
else:
print "You can use the imagemagick display tool to show the resulting imagesequence"
print "use the following line to show the demodulated TV-signal:"
print "display -depth 8 -size " + str(width) + "x" + str(
height) + " gray:" + filename
print "(Use the spacebar to advance to next frames)"
file_sink = blocks.file_sink(gr.sizeof_char, filename)
self.dst = file_sink
if options.nframes is None:
self.connect(self.src, self.agc)
else:
self.head = blocks.head(gr.sizeof_gr_complex,
int(options.nframes * width * height))
self.connect(self.src, self.head, self.agc)
self.connect(self.agc, self.am_demod, self.invert_and_scale,
self.set_blacklevel, self.f2uc, self.dst)
def __init__(self,frame,panel,vbox,argv):
stdgui2.std_top_block.__init__ (self,frame,panel,vbox,argv)
usage="%prog: [options] [input_filename]. \n If you don't specify an input filename the usrp will be used as source\n " \
"Make sure your input capture file containes interleaved shorts not complex floats"
parser=OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-a", "--args", type="string", default="",
help="UHD device address args [default=%default]")
parser.add_option("", "--spec", type="string", default=None,
help="Subdevice of UHD device where appropriate")
parser.add_option("-A", "--antenna", type="string", default=None,
help="select Rx Antenna where appropriate")
parser.add_option("-s", "--samp-rate", type="eng_float", default=1e6,
help="set sample rate")
parser.add_option("-f", "--freq", type="eng_float", default=519.25e6,
help="set frequency to FREQ", metavar="FREQ")
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("-c", "--contrast", type="eng_float", default=1.0,
help="set contrast (default is 1.0)")
parser.add_option("-b", "--brightness", type="eng_float", default=0.0,
help="set brightness (default is 0)")
parser.add_option("-p", "--pal", action="store_true", default=False,
help="PAL video format (this is the default)")
parser.add_option("-n", "--ntsc", action="store_true", default=False,
help="NTSC video format")
parser.add_option("-o", "--out-filename", type="string", default="sdl",
help="For example out_raw_uchar.gray. If you don't specify an output filename you will get a video_sink_sdl realtime output window. You then need to have gr-video-sdl installed)")
parser.add_option("-r", "--repeat", action="store_false", default=True,
help="repeat file in a loop")
parser.add_option("", "--freq-min", type="eng_float", default=50.25e6,
help="Set a minimum frequency [default=%default]")
parser.add_option("", "--freq-max", type="eng_float", default=900.25e6,
help="Set a maximum frequency [default=%default]")
(options, args) = parser.parse_args()
if not ((len(args) == 1) or (len(args) == 0)):
parser.print_help()
sys.exit(1)
if len(args) == 1:
filename = args[0]
else:
filename = None
self.frame = frame
self.panel = panel
self.contrast = options.contrast
self.brightness = options.brightness
self.state = "FREQ"
self.freq = 0
self.tv_freq_min = options.freq_min
self.tv_freq_max = options.freq_max
# build graph
self.u=None
if not (options.out_filename=="sdl"):
options.repeat=False
usrp_rate = options.samp_rate
if not ((filename is None) or (filename=="usrp")):
# file is data source
self.filesource = gr.file_source(gr.sizeof_short,filename,options.repeat)
self.istoc = gr.interleaved_short_to_complex()
self.connect(self.filesource,self.istoc)
self.src=self.istoc
options.gain=0.0
self.gain=0.0
else: # use a UHD device
self.u = uhd.usrp_source(device_addr=options.args, stream_args=uhd.stream_args('fc32'))
# Set the subdevice spec
if(options.spec):
self.u.set_subdev_spec(options.spec, 0)
# Set the antenna
if(options.antenna):
self.u.set_antenna(options.antenna, 0)
self.u.set_samp_rate(usrp_rate)
dev_rate = self.u.get_samp_rate()
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.get_gain_range()
options.gain = float(g.start()+g.stop())/2.0
self.src=self.u
self.gain = options.gain
f2uc=gr.float_to_uchar()
# sdl window as final sink
if not (options.pal or options.ntsc):
options.pal=True #set default to PAL
if options.pal:
lines_per_frame=625.0
frames_per_sec=25.0
show_width=768
elif options.ntsc:
lines_per_frame=525.0
frames_per_sec=29.97002997
show_width=640
width=int(usrp_rate/(lines_per_frame*frames_per_sec))
height=int(lines_per_frame)
if (options.out_filename=="sdl"):
#Here comes the tv screen, you have to build and install
#gr-video-sdl for this (subproject of gnuradio, only in cvs
#for now)
try:
video_sink = video_sdl.sink_uc ( frames_per_sec, width, height, 0,
show_width, height)
except:
print "gr-video-sdl is not installed"
print "realtime \"sdl\" video output window is not available"
raise SystemExit, 1
self.dst=video_sink
else:
print "You can use the imagemagick display tool to show the resulting imagesequence"
print "use the following line to show the demodulated TV-signal:"
print "display -depth 8 -size " +str(width)+ "x" + str(height) \
+ " gray:" + options.out_filename
print "(Use the spacebar to advance to next frames)"
options.repeat=False
file_sink=gr.file_sink(gr.sizeof_char, options.out_filename)
self.dst =file_sink
self.agc=gr.agc_cc(1e-7,1.0,1.0) #1e-7
self.am_demod = gr.complex_to_mag ()
self.set_blacklevel=gr.add_const_ff(0.0)
self.invert_and_scale = gr.multiply_const_ff (0.0) #-self.contrast *128.0*255.0/(200.0)
# now wire it all together
#sample_rate=options.width*options.height*options.framerate
process_type='do_no_sync'
if process_type=='do_no_sync':
self.connect (self.src, self.agc,self.am_demod,
self.invert_and_scale, self.set_blacklevel,
f2uc,self.dst)
elif process_type=='do_tv_sync_adv':
#defaults: gr.tv_sync_adv (double sampling_freq, unsigned
#int tv_format,bool output_active_video_only=false, bool
#do_invert=false, double wanted_black_level=0.0, double
#wanted_white_level=255.0, double avg_alpha=0.1, double
#initial_gain=1.0, double initial_offset=0.0,bool
#debug=false)
#note, this block is not yet in cvs
self.tv_sync_adv=gr.tv_sync_adv(usrp_rate, 0, False, False,
0.0, 255.0, 0.01, 1.0, 0.0, False)
self.connect (self.src, self.am_demod, self.invert_and_scale,
self.tv_sync_adv, s2f, f2uc, self.dst)
elif process_type=='do_nullsink':
#self.connect (self.src, self.am_demod,self.invert_and_scale,f2uc,video_sink)
c2r=gr.complex_to_real()
nullsink=gr.null_sink(gr.sizeof_float)
self.connect (self.src, c2r,nullsink) #video_sink)
elif process_type=='do_tv_sync_corr':
frame_size=width*height #int(usrp_rate/25.0)
nframes=10# 32
search_window=20*nframes
debug=False
video_alpha=0.3 #0.1
corr_alpha=0.3
#Note: this block is not yet in cvs
tv_corr=gr.tv_correlator_ff(frame_size,nframes, search_window,
video_alpha, corr_alpha,debug)
shift=gr.add_const_ff(-0.7)
self.connect (self.src, self.agc, self.am_demod, tv_corr,
self.invert_and_scale, self.set_blacklevel,
f2uc, self.dst)
else: # process_type=='do_test_image':
src_vertical_bars = gr.sig_source_f (usrp_rate, gr.GR_SIN_WAVE,
10.0 *usrp_rate/320, 255,128)
self.connect(src_vertical_bars, f2uc, self.dst)
self._build_gui(vbox, usrp_rate, usrp_rate, usrp_rate)
frange = self.u.get_freq_range()
if(frange.start() > self.tv_freq_max or frange.stop() < self.tv_freq_min):
sys.stderr.write("Radio does not support required frequency range.\n")
sys.exit(1)
if(options.freq < self.tv_freq_min or options.freq > self.tv_freq_max):
sys.stderr.write("Requested frequency is outside of required frequency range.\n")
sys.exit(1)
# set initial values
self.set_gain(options.gain)
self.set_contrast(self.contrast)
self.set_brightness(options.brightness)
if not(self.set_freq(options.freq)):
self._set_status_msg("Failed to set initial frequency")
def __init__(self):
gr.top_block.__init__(self)
usage=("%prog: [options] output_filename.\nSpecial output_filename" + \
"\"sdl\" will use video_sink_sdl as realtime output window. " + \
"You then need to have gr-video-sdl installed.\n" +\
"Make sure your input capture file containes interleaved " + \
"shorts not complex floats")
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-a", "--args", type="string", default="",
help="UHD device address args [default=%default]")
parser.add_option("", "--spec", type="string", default=None,
help="Subdevice of UHD device where appropriate")
parser.add_option("-A", "--antenna", type="string", default=None,
help="select Rx Antenna where appropriate")
parser.add_option("-s", "--samp-rate", type="eng_float", default=1e6,
help="set sample rate")
parser.add_option("-c", "--contrast", type="eng_float", default=1.0,
help="set contrast (default is 1.0)")
parser.add_option("-b", "--brightness", type="eng_float", default=0.0,
help="set brightness (default is 0)")
parser.add_option("-i", "--in-filename", type="string", default=None,
help="Use input file as source. samples must be " + \
"interleaved shorts \n Use usrp_rx_file.py or " + \
"usrp_rx_cfile.py --output-shorts.\n Special " + \
"name \"usrp\" results in realtime capturing " + \
"and processing using usrp.\n" + \
"You then probably need a decimation factor of 64 or higher.")
parser.add_option("-f", "--freq", type="eng_float", default=519.25e6,
help="set frequency to FREQ.\nNote that the frequency of the video carrier is not at the middle of the TV channel", metavar="FREQ")
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("-p", "--pal", action="store_true", default=False,
help="PAL video format (this is the default)")
parser.add_option("-n", "--ntsc", action="store_true", default=False,
help="NTSC video format")
parser.add_option("-r", "--repeat", action="store_false", default=True,
help="repeat in_file in a loop")
parser.add_option("-N", "--nframes", type="eng_float", default=None,
help="number of frames to collect [default=+inf]")
parser.add_option("", "--freq-min", type="eng_float", default=50.25e6,
help="Set a minimum frequency [default=%default]")
parser.add_option("", "--freq-max", type="eng_float", default=900.25e6,
help="Set a maximum frequency [default=%default]")
(options, args) = parser.parse_args ()
if not (len(args) == 1):
parser.print_help()
sys.stderr.write('You must specify the output. FILENAME or sdl \n');
sys.exit(1)
filename = args[0]
self.tv_freq_min = options.freq_min
self.tv_freq_max = options.freq_max
if options.in_filename is None:
parser.print_help()
sys.stderr.write('You must specify the input -i FILENAME or -i usrp\n');
raise SystemExit, 1
if not (filename=="sdl"):
options.repeat=False
input_rate = options.samp_rate
print "video sample rate %s" % (eng_notation.num_to_str(input_rate))
if not (options.in_filename=="usrp"):
# file is data source, capture with usr_rx_csfile.py
self.filesource = gr.file_source(gr.sizeof_short,
options.in_filename,
options.repeat)
self.istoc = gr.interleaved_short_to_complex()
self.connect(self.filesource,self.istoc)
self.src=self.istoc
else:
if options.freq is None:
parser.print_help()
sys.stderr.write('You must specify the frequency with -f FREQ\n');
raise SystemExit, 1
# build the graph
self.u = uhd.usrp_source(device_addr=options.args, stream_args=uhd.stream_args('fc32'))
# Set the subdevice spec
if(options.spec):
self.u.set_subdev_spec(options.spec, 0)
# Set the antenna
if(options.antenna):
self.u.set_antenna(options.antenna, 0)
self.u.set_samp_rate(input_rate)
dev_rate = self.u.get_samp_rate()
self.src=self.u
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.get_gain_range()
options.gain = float(g.start()+g.stop())/2.0
self.u.set_gain(options.gain)
r = self.u.set_center_freq(options.freq)
if not r:
sys.stderr.write('Failed to set frequency\n')
raise SystemExit, 1
self.agc = gr.agc_cc(1e-7,1.0,1.0) #1e-7
self.am_demod = gr.complex_to_mag ()
self.set_blacklevel = gr.add_const_ff(options.brightness +255.0)
self.invert_and_scale = gr.multiply_const_ff (-options.contrast *128.0*255.0/(200.0))
self.f2uc = gr.float_to_uchar()
# sdl window as final sink
if not (options.pal or options.ntsc):
options.pal=True #set default to PAL
if options.pal:
lines_per_frame=625.0
frames_per_sec=25.0
show_width=768
elif options.ntsc:
lines_per_frame=525.0
frames_per_sec=29.97002997
show_width=640
width=int(input_rate/(lines_per_frame*frames_per_sec))
height=int(lines_per_frame)
if filename=="sdl":
#Here comes the tv screen, you have to build and install
#gr-video-sdl for this (subproject of gnuradio, only in cvs
#for now)
try:
video_sink = video_sdl.sink_uc(frames_per_sec, width, height, 0,
show_width,height)
except:
print "gr-video-sdl is not installed"
print "realtime \"sdl\" video output window is not available"
raise SystemExit, 1
self.dst=video_sink
else:
print "You can use the imagemagick display tool to show the resulting imagesequence"
print "use the following line to show the demodulated TV-signal:"
print "display -depth 8 -size " +str(width)+ "x" + str(height) + " gray:" +filename
print "(Use the spacebar to advance to next frames)"
file_sink=gr.file_sink(gr.sizeof_char, filename)
self.dst =file_sink
if options.nframes is None:
self.connect(self.src, self.agc)
else:
self.head = gr.head(gr.sizeof_gr_complex, int(options.nframes*width*height))
self.connect(self.src, self.head, self.agc)
self.connect (self.agc, self.am_demod, self.invert_and_scale,
self.set_blacklevel, self.f2uc, self.dst)
def __init__(self):
gr.top_block.__init__(self)
usage="%prog: [options] output_filename. \n Special output_filename \"sdl\" will use video_sink_sdl as realtime output window. " \
"You then need to have gr-video-sdl installed. \n" \
"Make sure your input capture file containes interleaved shorts not complex floats"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-R",
"--rx-subdev-spec",
type="subdev",
default=(0, 0),
help="select USRP Rx side A or B (default=A)")
parser.add_option("-c",
"--contrast",
type="eng_float",
default=1.0,
help="set contrast (default is 1.0)")
parser.add_option("-b",
"--brightness",
type="eng_float",
default=0.0,
help="set brightness (default is 0)")
parser.add_option(
"-d",
"--decim",
type="int",
default=8,
help="set fgpa decimation rate to DECIM [default=%default]")
parser.add_option(
"-i",
"--in-filename",
type="string",
default=None,
help=
"Use input file as source. samples must be interleaved shorts \n "
+ "Use usrp_rx_file.py or usrp_rx_cfile.py --output-shorts. \n"
"Special name \"usrp\" results in realtime capturing and processing using usrp. \n"
+ "You then probably need a decimation factor of 64 or higher.")
parser.add_option(
"-f",
"--freq",
type="eng_float",
default=None,
help=
"set frequency to FREQ.\nNote that the frequency of the video carrier is not at the middle of the TV channel",
metavar="FREQ")
parser.add_option("-g",
"--gain",
type="eng_float",
default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("-p",
"--pal",
action="store_true",
default=False,
help="PAL video format (this is the default)")
parser.add_option("-n",
"--ntsc",
action="store_true",
default=False,
help="NTSC video format")
parser.add_option("-r",
"--repeat",
action="store_false",
default=True,
help="repeat in_file in a loop")
parser.add_option("-8",
"--width-8",
action="store_true",
default=False,
help="Enable 8-bit samples across USB")
parser.add_option("-N",
"--nframes",
type="eng_float",
default=None,
help="number of frames to collect [default=+inf]")
parser.add_option("--no-hb",
action="store_true",
default=False,
help="don't use halfband filter in usrp")
(options, args) = parser.parse_args()
if not (len(args) == 1):
parser.print_help()
sys.stderr.write('You must specify the output. FILENAME or sdl \n')
sys.exit(1)
filename = args[0]
if options.in_filename is None:
parser.print_help()
sys.stderr.write(
'You must specify the input -i FILENAME or -i usrp\n')
raise SystemExit, 1
if not (filename == "sdl"):
options.repeat = False
if not (options.in_filename == "usrp"):
self.filesource = gr.file_source(
gr.sizeof_short, options.in_filename, options.repeat
) # file is data source, capture with usr_rx_csfile.py
self.istoc = gr.interleaved_short_to_complex()
self.connect(self.filesource, self.istoc)
self.adc_rate = 64e6
self.src = self.istoc
else:
if options.freq is None:
parser.print_help()
sys.stderr.write(
'You must specify the frequency with -f FREQ\n')
raise SystemExit, 1
if abs(options.freq) < 1e6:
options.freq *= 1e6
if options.no_hb or (options.decim < 8):
self.fpga_filename = "std_4rx_0tx.rbf" #contains 4 Rx paths without halfbands and 0 tx paths
else:
self.fpga_filename = "std_2rxhb_2tx.rbf" # contains 2 Rx paths with halfband filters and 2 tx paths (the default)
# build the graph
self.u = usrp.source_c(decim_rate=options.decim,
fpga_filename=self.fpga_filename)
self.src = self.u
if options.width_8:
sample_width = 8
sample_shift = 8
format = self.u.make_format(sample_width, sample_shift)
r = self.u.set_format(format)
self.adc_rate = self.u.adc_freq()
if options.rx_subdev_spec is None:
options.rx_subdev_spec = usrp.pick_rx_subdevice(self.u)
self.u.set_mux(
usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec))
# determine the daughterboard subdevice we're using
self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec)
print "Using RX d'board %s" % (self.subdev.side_and_name(), )
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.subdev.gain_range()
options.gain = float(g[0] + g[1]) / 2
self.subdev.set_gain(options.gain)
r = self.u.tune(0, self.subdev, options.freq)
if not r:
sys.stderr.write('Failed to set frequency\n')
raise SystemExit, 1
input_rate = self.adc_rate / options.decim
print "video sample rate %s" % (eng_notation.num_to_str(input_rate))
self.agc = gr.agc_cc(1e-7, 1.0, 1.0) #1e-7
self.am_demod = gr.complex_to_mag()
self.set_blacklevel = gr.add_const_ff(options.brightness + 255.0)
self.invert_and_scale = gr.multiply_const_ff(-options.contrast *
128.0 * 255.0 / (200.0))
self.f2uc = gr.float_to_uchar()
# sdl window as final sink
if not (options.pal or options.ntsc):
options.pal = True #set default to PAL
if options.pal:
lines_per_frame = 625.0
frames_per_sec = 25.0
show_width = 768
elif options.ntsc:
lines_per_frame = 525.0
frames_per_sec = 29.97002997
show_width = 640
width = int(input_rate / (lines_per_frame * frames_per_sec))
height = int(lines_per_frame)
if filename == "sdl":
#Here comes the tv screen, you have to build and install gr-video-sdl for this (subproject of gnuradio, only in cvs for now)
try:
video_sink = video_sdl.sink_uc(frames_per_sec, width, height,
0, show_width, height)
except:
print "gr-video-sdl is not installed"
print "realtime \"sdl\" video output window is not available"
raise SystemExit, 1
self.dst = video_sink
else:
print "You can use the imagemagick display tool to show the resulting imagesequence"
print "use the following line to show the demodulated TV-signal:"
print "display -depth 8 -size " + str(width) + "x" + str(
height) + " gray:" + filename
print "(Use the spacebar to advance to next frames)"
file_sink = gr.file_sink(gr.sizeof_char, filename)
self.dst = file_sink
if options.nframes is None:
self.connect(self.src, self.agc)
else:
self.head = gr.head(gr.sizeof_gr_complex,
int(options.nframes * width * height))
self.connect(self.src, self.head, self.agc)
self.connect(self.agc, self.am_demod, self.invert_and_scale,
self.set_blacklevel, self.f2uc, self.dst)
def __init__(self,frame,panel,vbox,argv):
stdgui2.std_top_block.__init__ (self,frame,panel,vbox,argv)
usage="%prog: [options] [input_filename]. \n If you don't specify an input filename the usrp will be used as source\n " \
"Make sure your input capture file containes interleaved shorts not complex floats"
parser=OptionParser(option_class=eng_option)
parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=None,
help="select USRP Rx side A or B (default=A)")
parser.add_option("-d", "--decim", type="int", default=64,
help="set fgpa decimation rate to DECIM [default=%default]")
parser.add_option("-f", "--freq", type="eng_float", default=519.25e6,
help="set frequency to FREQ", metavar="FREQ")
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("-c", "--contrast", type="eng_float", default=1.0,
help="set contrast (default is 1.0)")
parser.add_option("-b", "--brightness", type="eng_float", default=0.0,
help="set brightness (default is 0)")
parser.add_option("-8", "--width-8", action="store_true", default=False,
help="Enable 8-bit samples across USB")
parser.add_option("-p", "--pal", action="store_true", default=False,
help="PAL video format (this is the default)")
parser.add_option("-n", "--ntsc", action="store_true", default=False,
help="NTSC video format")
parser.add_option("-o", "--out-filename", type="string", default="sdl",
help="For example out_raw_uchar.gray. If you don't specify an output filename you will get a video_sink_sdl realtime output window. You then need to have gr-video-sdl installed)")
parser.add_option("-r", "--repeat", action="store_false", default=True,
help="repeat file in a loop")
parser.add_option("-N", "--no-hb", action="store_true", default=False,
help="don't use halfband filter in usrp")
(options, args) = parser.parse_args()
if not ((len(args) == 1) or (len(args) == 0)):
parser.print_help()
sys.exit(1)
if len(args) == 1:
filename = args[0]
else:
filename = None
self.frame = frame
self.panel = panel
self.contrast = options.contrast
self.brightness = options.brightness
self.state = "FREQ"
self.freq = 0
# build graph
self.u=None
usrp_decim = options.decim # 32
if not (options.out_filename=="sdl"):
options.repeat=False
if not ((filename is None) or (filename=="usrp")):
self.filesource = gr.file_source(gr.sizeof_short,filename,options.repeat) # file is data source
self.istoc = gr.interleaved_short_to_complex()
self.connect(self.filesource,self.istoc)
adc_rate=64e6
self.src=self.istoc
options.gain=0.0
self.gain=0.0
else:
if options.no_hb or (options.decim<8):
self.fpga_filename="std_4rx_0tx.rbf" #contains 4 Rx paths without halfbands and 0 tx paths
else:
self.fpga_filename="std_2rxhb_2tx.rbf" # contains 2 Rx paths with halfband filters and 2 tx paths (the default)
self.u = usrp.source_c(0,fpga_filename=self.fpga_filename) # usrp is data source
if options.width_8:
sample_width = 8
sample_shift = 8
format = self.u.make_format(sample_width, sample_shift)
r = self.u.set_format(format)
adc_rate = self.u.adc_rate() # 64 MS/s
self.u.set_decim_rate(usrp_decim)
if options.rx_subdev_spec is None:
options.rx_subdev_spec = pick_subdevice(self.u)
self.u.set_mux(usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec)
print "Using RX d'board %s" % (self.subdev.side_and_name(),)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.subdev.gain_range()
options.gain = float(g[0]+g[1])/2
self.src=self.u
usrp_rate = adc_rate / usrp_decim # 320 kS/s
f2uc=gr.float_to_uchar()
# sdl window as final sink
if not (options.pal or options.ntsc):
options.pal=True #set default to PAL
if options.pal:
lines_per_frame=625.0
frames_per_sec=25.0
show_width=768
elif options.ntsc:
lines_per_frame=525.0
frames_per_sec=29.97002997
show_width=640
width=int(usrp_rate/(lines_per_frame*frames_per_sec))
height=int(lines_per_frame)
if (options.out_filename=="sdl"):
#Here comes the tv screen, you have to build and install gr-video-sdl for this (subproject of gnuradio, only in cvs for now)
try:
video_sink = video_sdl.sink_uc ( frames_per_sec, width, height,0,show_width,height)
except:
print "gr-video-sdl is not installed"
print "realtime \"sdl\" video output window is not available"
raise SystemExit, 1
self.dst=video_sink
else:
print "You can use the imagemagick display tool to show the resulting imagesequence"
print "use the following line to show the demodulated TV-signal:"
print "display -depth 8 -size " +str(width)+ "x" + str(height) + " gray:" + options.out_filename
print "(Use the spacebar to advance to next frames)"
options.repeat=False
file_sink=gr.file_sink(gr.sizeof_char, options.out_filename)
self.dst =file_sink
self.agc=gr.agc_cc(1e-7,1.0,1.0) #1e-7
self.am_demod = gr.complex_to_mag ()
self.set_blacklevel=gr.add_const_ff(0.0)
self.invert_and_scale = gr.multiply_const_ff (0.0) #-self.contrast *128.0*255.0/(200.0)
# now wire it all together
#sample_rate=options.width*options.height*options.framerate
process_type='do_no_sync'
if process_type=='do_no_sync':
self.connect (self.src, self.agc,self.am_demod,self.invert_and_scale, self.set_blacklevel,f2uc,self.dst)
elif process_type=='do_tv_sync_adv':
#defaults: gr.tv_sync_adv (double sampling_freq, unsigned int tv_format,bool output_active_video_only=false, bool do_invert=false, double wanted_black_level=0.0, double wanted_white_level=255.0, double avg_alpha=0.1, double initial_gain=1.0, double initial_offset=0.0,bool debug=false)
self.tv_sync_adv=gr.tv_sync_adv(usrp_rate,0,False,False,0.0,255.0,0.01,1.0,0.0,False) #note, this block is not yet in cvs
self.connect (self.src, self.am_demod,self.invert_and_scale,self.tv_sync_adv,s2f,f2uc,self.dst)
elif process_type=='do_nullsink':
#self.connect (self.src, self.am_demod,self.invert_and_scale,f2uc,video_sink)
c2r=gr.complex_to_real()
nullsink=gr.null_sink(gr.sizeof_float)
self.connect (self.src, c2r,nullsink) #video_sink)
elif process_type=='do_tv_sync_corr':
frame_size=width*height #int(usrp_rate/25.0)
nframes=10# 32
search_window=20*nframes
debug=False
video_alpha=0.3 #0.1
corr_alpha=0.3
tv_corr=gr.tv_correlator_ff(frame_size,nframes, search_window, video_alpha, corr_alpha,debug) #Note: this block is not yet in cvs
shift=gr.add_const_ff(-0.7)
self.connect (self.src, self.agc,self.am_demod,tv_corr,self.invert_and_scale, self.set_blacklevel,f2uc,self.dst) #self.agc,
else: # process_type=='do_test_image':
src_vertical_bars = gr.sig_source_f (usrp_rate, gr.GR_SIN_WAVE, 10.0 *usrp_rate/320, 255,128)
self.connect(src_vertical_bars,f2uc,self.dst)
self._build_gui(vbox, usrp_rate, usrp_rate, usrp_rate)
if abs(options.freq) < 1e6:
options.freq *= 1e6
# set initial values
self.set_gain(options.gain)
self.set_contrast(self.contrast)
self.set_brightness(options.brightness)
if not(self.set_freq(options.freq)):
self._set_status_msg("Failed to set initial frequency")
def __init__(self):
gr.top_block.__init__(self)
usage="%prog: [options] output_filename. \n Special output_filename \"sdl\" will use video_sink_sdl as realtime output window. " \
"You then need to have gr-video-sdl installed. \n" \
"Make sure your input capture file containes interleaved shorts not complex floats"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0, 0),
help="select USRP Rx side A or B (default=A)")
parser.add_option("-c", "--contrast", type="eng_float", default=1.0,
help="set contrast (default is 1.0)")
parser.add_option("-b", "--brightness", type="eng_float", default=0.0,
help="set brightness (default is 0)")
parser.add_option("-d", "--decim", type="int", default=8,
help="set fgpa decimation rate to DECIM [default=%default]")
parser.add_option("-i", "--in-filename", type="string", default=None,
help="Use input file as source. samples must be interleaved shorts \n " +
"Use usrp_rx_file.py or usrp_rx_cfile.py --output-shorts. \n"
"Special name \"usrp\" results in realtime capturing and processing using usrp. \n" +
"You then probably need a decimation factor of 64 or higher.")
parser.add_option("-f", "--freq", type="eng_float", default=None,
help="set frequency to FREQ.\nNote that the frequency of the video carrier is not at the middle of the TV channel", metavar="FREQ")
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("-p", "--pal", action="store_true", default=False,
help="PAL video format (this is the default)")
parser.add_option("-n", "--ntsc", action="store_true", default=False,
help="NTSC video format")
parser.add_option("-r", "--repeat", action="store_false", default=True,
help="repeat in_file in a loop")
parser.add_option("-8", "--width-8", action="store_true", default=False,
help="Enable 8-bit samples across USB")
parser.add_option("-N", "--nframes", type="eng_float", default=None,
help="number of frames to collect [default=+inf]")
parser.add_option( "--no-hb", action="store_true", default=False,
help="don't use halfband filter in usrp")
(options, args) = parser.parse_args ()
if not (len(args) == 1):
parser.print_help()
sys.stderr.write('You must specify the output. FILENAME or sdl \n');
sys.exit(1)
filename = args[0]
if options.in_filename is None:
parser.print_help()
sys.stderr.write('You must specify the input -i FILENAME or -i usrp\n');
raise SystemExit, 1
if not (filename=="sdl"):
options.repeat=False
if not (options.in_filename=="usrp"):
self.filesource = gr.file_source(gr.sizeof_short,options.in_filename,options.repeat) # file is data source, capture with usr_rx_csfile.py
self.istoc = gr.interleaved_short_to_complex()
self.connect(self.filesource,self.istoc)
self.adc_rate=64e6
self.src=self.istoc
else:
if options.freq is None:
parser.print_help()
sys.stderr.write('You must specify the frequency with -f FREQ\n');
raise SystemExit, 1
if abs(options.freq) < 1e6:
options.freq *= 1e6
if options.no_hb or (options.decim<8):
self.fpga_filename="std_4rx_0tx.rbf" #contains 4 Rx paths without halfbands and 0 tx paths
else:
self.fpga_filename="std_2rxhb_2tx.rbf" # contains 2 Rx paths with halfband filters and 2 tx paths (the default)
# build the graph
self.u = usrp.source_c(decim_rate=options.decim,fpga_filename=self.fpga_filename)
self.src=self.u
if options.width_8:
sample_width = 8
sample_shift = 8
format = self.u.make_format(sample_width, sample_shift)
r = self.u.set_format(format)
self.adc_rate=self.u.adc_freq()
if options.rx_subdev_spec is None:
options.rx_subdev_spec = usrp.pick_rx_subdevice(self.u)
self.u.set_mux(usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec))
# determine the daughterboard subdevice we're using
self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec)
print "Using RX d'board %s" % (self.subdev.side_and_name(),)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.subdev.gain_range()
options.gain = float(g[0]+g[1])/2
self.subdev.set_gain(options.gain)
r = self.u.tune(0, self.subdev, options.freq)
if not r:
sys.stderr.write('Failed to set frequency\n')
raise SystemExit, 1
input_rate = self.adc_rate / options.decim
print "video sample rate %s" % (eng_notation.num_to_str(input_rate))
self.agc=gr.agc_cc(1e-7,1.0,1.0) #1e-7
self.am_demod = gr.complex_to_mag ()
self.set_blacklevel=gr.add_const_ff(options.brightness +255.0)
self.invert_and_scale = gr.multiply_const_ff (-options.contrast *128.0*255.0/(200.0))
self.f2uc=gr.float_to_uchar()
# sdl window as final sink
if not (options.pal or options.ntsc):
options.pal=True #set default to PAL
if options.pal:
lines_per_frame=625.0
frames_per_sec=25.0
show_width=768
elif options.ntsc:
lines_per_frame=525.0
frames_per_sec=29.97002997
show_width=640
width=int(input_rate/(lines_per_frame*frames_per_sec))
height=int(lines_per_frame)
if filename=="sdl":
#Here comes the tv screen, you have to build and install gr-video-sdl for this (subproject of gnuradio, only in cvs for now)
try:
video_sink = video_sdl.sink_uc ( frames_per_sec, width, height,0,show_width,height)
except:
print "gr-video-sdl is not installed"
print "realtime \"sdl\" video output window is not available"
raise SystemExit, 1
self.dst=video_sink
else:
print "You can use the imagemagick display tool to show the resulting imagesequence"
print "use the following line to show the demodulated TV-signal:"
print "display -depth 8 -size " +str(width)+ "x" + str(height) + " gray:" +filename
print "(Use the spacebar to advance to next frames)"
file_sink=gr.file_sink(gr.sizeof_char, filename)
self.dst =file_sink
if options.nframes is None:
self.connect(self.src, self.agc)
else:
self.head = gr.head(gr.sizeof_gr_complex, int(options.nframes*width*height))
self.connect(self.src, self.head, self.agc)
self.connect (self.agc,self.am_demod,self.invert_and_scale, self.set_blacklevel,self.f2uc,self.dst)
