def _setup_rpc_manager(self):
## Adding rpc manager for Transmitter
self.rpc_mgr_tx = zeromq.rpc_manager()
self.rpc_mgr_tx.set_reply_socket("tcp://*:6660")
self.rpc_mgr_tx.start_watcher()
## Adding rpc manager for Receiver
self.rpc_mgr_rx = zeromq.rpc_manager()
self.rpc_mgr_rx.set_reply_socket("tcp://*:5550")
self.rpc_mgr_rx.start_watcher()
## Adding interfaces
self.rpc_mgr_tx.add_interface("set_amplitude",
self.txpath.set_rms_amplitude)
self.rpc_mgr_tx.add_interface("get_tx_parameters",
self.txpath.get_tx_parameters)
self.rpc_mgr_tx.add_interface(
"set_modulation", self.txpath.allocation_src.set_allocation)
self.rpc_mgr_rx.add_interface("set_scatter_subcarrier",
self.rxpath.set_scatterplot_subc)
if self.ideal or self.ideal2:
self.rpc_mgr_tx.add_interface("set_amplitude_ideal",
self.set_rms_amplitude)
else:
self.rpc_mgr_tx.add_interface("set_amplitude_ideal",
self.set_fake_amplitude)
def _setup_rpc_manager(self):
## Adding rpc manager for Transmitter
self.rpc_mgr_tx = zeromq.rpc_manager()
self.rpc_mgr_tx.set_reply_socket("tcp://*:6660")
self.rpc_mgr_tx.start_watcher()
## Adding rpc manager for Receiver
self.rpc_mgr_rx = zeromq.rpc_manager()
self.rpc_mgr_rx.set_reply_socket("tcp://*:5550")
self.rpc_mgr_rx.start_watcher()
## Adding interfaces
self.rpc_mgr_tx.add_interface("set_amplitude",self.txpath.set_rms_amplitude)
self.rpc_mgr_tx.add_interface("get_tx_parameters",self.txpath.get_tx_parameters)
self.rpc_mgr_tx.add_interface("set_modulation",self.txpath.allocation_src.set_allocation)
self.rpc_mgr_rx.add_interface("set_observed_subcarrier",self.rxpath.set_observed_subc)
self.rpc_mgr_tx.add_interface("set_allocation_scheme",self.txpath.allocation_src.set_allocation_scheme)
self.rpc_mgr_tx.add_interface("set_data_rate",self.txpath.allocation_src.set_data_rate)
self.rpc_mgr_tx.add_interface("set_power_limit",self.txpath.allocation_src.set_power_limit)
self.rpc_mgr_tx.add_interface("set_gap",self.txpath.allocation_src.set_gap)
self.rpc_mgr_tx.add_interface("set_resource_block_size",self.txpath.allocation_src.set_resource_block_size)
self.rpc_mgr_tx.add_interface("set_resource_block_number",self.txpath.allocation_src.set_resource_block_number)
if self.ideal or self.ideal2:
self.rpc_mgr_tx.add_interface("set_amplitude_ideal",self.set_rms_amplitude)
else:
self.rpc_mgr_tx.add_interface("set_amplitude_ideal",self.set_fake_amplitude)
def __init__(self, options):
gr.top_block.__init__(self)
self.options = options
# socket addresses
rpc_adr = "tcp://*:6667"
probe_adr = "tcp://*:5557"
source_adr = "tcp://" + self.options.servername + ":5555"
# blocks
#self.zmq_source = zeromq.req_source(gr.sizeof_float, 1, source_adr)
#self.zmq_source = zeromq.pull_source(gr.sizeof_float, 1, source_adr)
self.zmq_source = zeromq.sub_source(gr.sizeof_float, 1, source_adr)
#self.zmq_probe = zeromq.push_sink(gr.sizeof_float,probe_adr)
self.zmq_probe = zeromq.pub_sink(gr.sizeof_float, probe_adr)
# connects
self.connect(self.zmq_source, self.zmq_probe)
# ZeroMQ
self.rpc_manager = zeromq.rpc_manager()
self.rpc_manager.set_reply_socket(rpc_adr)
self.rpc_manager.add_interface("start_fg", self.start_fg)
self.rpc_manager.add_interface("stop_fg", self.stop_fg)
self.rpc_manager.start_watcher()
def __init__(self, options):
gr.top_block.__init__(self)
self.options = options
# socket addresses
rpc_adr = "tcp://*:6667"
probe_adr = "tcp://*:5557"
source_adr = "tcp://"+self.options.servername+":5555"
# blocks
#self.zmq_source = zeromq.req_source(gr.sizeof_float, 1, source_adr)
#self.zmq_source = zeromq.pull_source(gr.sizeof_float, 1, source_adr)
self.zmq_source = zeromq.sub_source(gr.sizeof_float, 1, source_adr)
#self.zmq_probe = zeromq.push_sink(gr.sizeof_float, 1, probe_adr)
self.zmq_probe = zeromq.pub_sink(gr.sizeof_float, 1, probe_adr)
# connects
self.connect(self.zmq_source, self.zmq_probe)
# ZeroMQ
self.rpc_manager = zeromq.rpc_manager()
self.rpc_manager.set_reply_socket(rpc_adr)
self.rpc_manager.add_interface("start_fg",self.start_fg)
self.rpc_manager.add_interface("stop_fg",self.stop_fg)
self.rpc_manager.start_watcher()
def _setup_rpc_manager(self):
## Adding rpc manager for Transmitter
self.rpc_mgr_tx = zeromq.rpc_manager()
self.rpc_mgr_tx.set_reply_socket("tcp://*:6660")
self.rpc_mgr_tx.start_watcher()
## Adding rpc manager for Receiver
self.rpc_mgr_rx = zeromq.rpc_manager()
self.rpc_mgr_rx.set_reply_socket("tcp://*:5550")
self.rpc_mgr_rx.start_watcher()
## Adding interfaces
self.rpc_mgr_tx.add_interface("set_amplitude",self.txpath.set_rms_amplitude)
self.rpc_mgr_tx.add_interface("get_tx_parameters",self.txpath.get_tx_parameters)
self.rpc_mgr_tx.add_interface("set_modulation",self.txpath.allocation_src.set_allocation)
self.rpc_mgr_rx.add_interface("set_scatter_subcarrier",self.rxpath.set_scatterplot_subc)
def _setup_rpc_manager(self):
## Adding rpc manager for Receiver
self.rpc_mgr_rx = zeromq.rpc_manager()
self.rpc_mgr_rx.set_reply_socket("tcp://*:5550")
self.rpc_mgr_rx.start_watcher()
## Adding interfaces
self.rpc_mgr_rx.add_interface("set_scatter_subcarrier",self.rxpath.set_scatterplot_subc)
self.rpc_mgr_rx.add_interface("set_rx_gain",self.set_rx_gain)
def setup_rpc_manager(self):
## Adding rpc manager for Receiver
self.rpc_mgr_rx = zeromq.rpc_manager()
self.rpc_mgr_rx.set_reply_socket("tcp://*:5550")
self.rpc_mgr_rx.start_watcher()
## Adding interfaces
self.rpc_mgr_rx.add_interface("set_observed_subcarrier",
self.rxpath.set_observed_subc)
self.rpc_mgr_rx.add_interface("set_rx_gain", self.set_rx_gain)
def __init__(self,
frequency=220.352e6,
rf_gain=25,
if_gain=0,
bb_gain=0,
use_zeromq=False,
server="tcp://127.0.0.1:10444",
server_control="tcp://127.0.0.1:10445"):
gr.hier_block2.__init__(
self,
"osmo_or_zmq_source",
# Input signature
gr.io_signature(0, 0, 1),
# Output signature
gr.io_signature(1, 1, gr.sizeof_gr_complex))
samp_rate = 2000000
self.use_zeromq = use_zeromq
if not use_zeromq:
import osmosdr
self.osmosdr_source_0 = osmosdr.source(args="numchan=" + str(1) +
" " + '')
self.osmosdr_source_0.set_sample_rate(samp_rate)
self.osmosdr_source_0.set_center_freq(frequency, 0)
self.osmosdr_source_0.set_freq_corr(0, 0)
self.osmosdr_source_0.set_dc_offset_mode(0, 0)
self.osmosdr_source_0.set_iq_balance_mode(0, 0)
self.osmosdr_source_0.set_gain_mode(False, 0)
self.osmosdr_source_0.set_gain(rf_gain, 0)
self.osmosdr_source_0.set_if_gain(if_gain, 0)
self.osmosdr_source_0.set_bb_gain(bb_gain, 0)
self.osmosdr_source_0.set_antenna('', 0)
self.osmosdr_source_0.set_bandwidth(2000000, 0)
self.src = self.osmosdr_source_0
else:
from gnuradio import zeromq
self.zeromq_source = zeromq.sub_source(gr.sizeof_gr_complex, 1,
server, 100, False, -1)
self.rpc_mgr_server = zeromq.rpc_manager()
self.rpc_mgr_server.set_request_socket(server_control)
self.rpc_mgr_server.request("set_sample_rate", [samp_rate])
self.rpc_mgr_server.request("set_rf_gain", [rf_gain])
self.rpc_mgr_server.request("set_if_gain", [if_gain])
self.rpc_mgr_server.request("set_bb_gain", [bb_gain])
self.rpc_mgr_server.request(
"set_ppm", [0]
) # Not using hardware correction since it behaves differently on different hardware
self.rpc_mgr_server.request("set_frequency", [frequency])
self.src = self.zeromq_source
self.connect(self.src, (self, 0))
def setup_transmitter_usrp0(self):
self.tb = gr.top_block()
self.txpath = transmit_path(self)
self.rpc_mgr_tx = zeromq.rpc_manager()
self.rpc_mgr_tx.set_reply_socket("tcp://*:6660")
self.rpc_mgr_tx.start_watcher()
## Adding interfaces
self.rpc_mgr_tx.add_interface("set_amplitude",self.txpath.set_rms_amplitude)
self.rpc_mgr_tx.add_interface("get_tx_parameters",self.txpath.get_tx_parameters)
self.rpc_mgr_tx.add_interface("set_modulation",self.txpath.allocation_src.set_allocation)
def setup_transmitter_fbmc0(self):
self.tb = gr.top_block()
self.txpath = transmit_path(self)
self.rpc_mgr_tx = zeromq.rpc_manager()
self.rpc_mgr_tx.set_reply_socket("tcp://*:6660")
self.rpc_mgr_tx.start_watcher()
## Adding interfaces
self.rpc_mgr_tx.add_interface("set_amplitude",self.txpath.set_rms_amplitude)
self.rpc_mgr_tx.add_interface("get_tx_parameters",self.txpath.get_tx_parameters)
self.rpc_mgr_tx.add_interface("set_modulation",self.txpath.allocation_src.set_allocation)
def setup_receiver_fbmc0(self):
self.tb = gr.top_block()
self.rxpath = receive_path(self)
self.rpc_mgr_rx = zeromq.rpc_manager()
self.rpc_mgr_rx.set_reply_socket("tcp://*:5550")
self.rpc_mgr_rx.start_watcher()
## Adding interfaces
self.rpc_mgr_rx.add_interface("set_scatter_subcarrier",
self.rxpath.set_scatterplot_subc)
def setup_receiver_usrp0(self):
self.tb = gr.top_block()
self.rxpath = receive_path(self)
self.rpc_mgr_rx = zeromq.rpc_manager()
self.rpc_mgr_rx.set_reply_socket("tcp://*:5550")
self.rpc_mgr_rx.start_watcher()
## Adding interfaces
self.rpc_mgr_rx.add_interface("set_scatter_subcarrier",self.rxpath.set_scatterplot_subc)
def __init__(self, frequency=220.352e6, rf_gain=25, if_gain=0, bb_gain=0, use_zeromq=False, server="tcp://127.0.0.1:10444", server_control="tcp://127.0.0.1:10445"):
gr.hier_block2.__init__(self,
"osmo_or_zmq_source",
# Input signature
gr.io_signature(0, 0, 1),
# Output signature
gr.io_signature(1, 1, gr.sizeof_gr_complex))
samp_rate = 2000000
self.use_zeromq = use_zeromq
if not use_zeromq:
import osmosdr
self.osmosdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + '' )
self.osmosdr_source_0.set_sample_rate(samp_rate)
self.osmosdr_source_0.set_center_freq(frequency, 0)
self.osmosdr_source_0.set_freq_corr(0, 0)
self.osmosdr_source_0.set_dc_offset_mode(0, 0)
self.osmosdr_source_0.set_iq_balance_mode(0, 0)
self.osmosdr_source_0.set_gain_mode(False, 0)
self.osmosdr_source_0.set_gain(rf_gain, 0)
self.osmosdr_source_0.set_if_gain(if_gain, 0)
self.osmosdr_source_0.set_bb_gain(bb_gain, 0)
self.osmosdr_source_0.set_antenna('', 0)
self.osmosdr_source_0.set_bandwidth(2000000, 0)
self.src = self.osmosdr_source_0
else:
from gnuradio import zeromq
self.zeromq_source = zeromq.sub_source(gr.sizeof_gr_complex, 1, server, 100, False, -1)
self.rpc_mgr_server = zeromq.rpc_manager()
self.rpc_mgr_server.set_request_socket(server_control)
self.rpc_mgr_server.request("set_sample_rate",[samp_rate])
self.rpc_mgr_server.request("set_rf_gain",[rf_gain])
self.rpc_mgr_server.request("set_if_gain",[if_gain])
self.rpc_mgr_server.request("set_bb_gain",[bb_gain])
self.rpc_mgr_server.request("set_ppm",[0]) # Not using hardware correction since it behaves differently on different hardware
self.rpc_mgr_server.request("set_frequency",[frequency])
self.src = self.zeromq_source
self.connect(self.src, (self, 0))
def __init__(self, options):
gr.top_block.__init__(self)
self.options = options
# socket addresses
rpc_adr = "tcp://*:6666"
probe_adr = "tcp://*:5556"
sink_adr = "tcp://*:5555"
# the strange sampling rate gives a nice movement in the plot :P
self.samp_rate = samp_rate = 48200
# blocks
self.gr_sig_source = analog.sig_source_f(samp_rate, analog.GR_SIN_WAVE,
1000, 1, 0)
self.throttle = blocks.throttle(gr.sizeof_float, samp_rate)
self.mult = blocks.multiply_const_ff(1)
#self.zmq_sink = zeromq.rep_sink(gr.sizeof_float, 1, sink_adr)
self.zmq_sink = zeromq.pub_sink(gr.sizeof_float, 1, sink_adr)
#self.zmq_sink = zeromq.push_sink(gr.sizeof_float, 1, sink_adr)
#self.zmq_probe = zeromq.push_sink(gr.sizeof_float, 1, probe_adr)
self.zmq_probe = zeromq.pub_sink(gr.sizeof_float, 1, probe_adr)
#self.null_sink = blocks.null_sink(gr.sizeof_float)
# connects
self.connect(self.gr_sig_source, self.mult, self.throttle,
self.zmq_sink)
self.connect(self.throttle, self.zmq_probe)
# ZeroMQ
self.rpc_manager = zeromq.rpc_manager()
self.rpc_manager.set_reply_socket(rpc_adr)
self.rpc_manager.add_interface("start_fg", self.start_fg)
self.rpc_manager.add_interface("stop_fg", self.stop_fg)
self.rpc_manager.add_interface("set_waveform", self.set_waveform)
self.rpc_manager.add_interface("set_k", self.mult.set_k)
self.rpc_manager.add_interface("get_sample_rate",
self.throttle.sample_rate)
self.rpc_manager.start_watcher()
def __init__(self, fft_length, subcarriers, data_blocks, frame_length,
cp_length, tx_freq, bandwidth):
bits = 8 * subcarriers * data_blocks # max. QAM256
samples_per_frame = frame_length * (fft_length + cp_length)
tb = 1.0 * samples_per_frame / bandwidth
print tb
print bandwidth
self.tx_parameters = {'carrier_frequency':tx_freq/1e9,'fft_size':fft_length, 'cp_size':cp_length \
, 'subcarrier_spacing':bandwidth/fft_length/1e3 \
,'data_subcarriers':subcarriers, 'bandwidth':bandwidth/1e6 \
, 'frame_length':frame_length \
, 'symbol_time':1.0*(cp_length + fft_length)/bandwidth*1e6, 'max_data_rate':(bits/tb)/1e6}
#path1 = eval(comm1)
#path2 = eval(comm2)
self.rpc_mgr_tx = zeromq.rpc_manager()
self.rpc_mgr_tx.set_reply_socket("tcp://*:6660")
self.rpc_mgr_tx.start_watcher()
self.rpc_mgr_tx.add_interface("get_tx_parameters",
self.get_tx_parameters)
def __init__(self, options):
gr.top_block.__init__(self)
self.options = options
# socket addresses
rpc_adr = "tcp://*:6666"
probe_adr = "tcp://*:5556"
sink_adr = "tcp://*:5555"
# the strange sampling rate gives a nice movement in the plot :P
self.samp_rate = samp_rate = 48200
# blocks
self.gr_sig_source = analog.sig_source_f(samp_rate, analog.GR_SIN_WAVE , 1000, 1, 0)
self.throttle = blocks.throttle(gr.sizeof_float, samp_rate)
self.mult = blocks.multiply_const_ff(1)
#self.zmq_sink = zeromq.rep_sink(gr.sizeof_float, 1, sink_adr)
self.zmq_sink = zeromq.pub_sink(gr.sizeof_float, 1, sink_adr)
#self.zmq_sink = zeromq.push_sink(gr.sizeof_float, 1, sink_adr)
#self.zmq_probe = zeromq.push_sink(gr.sizeof_float, probe_adr)
self.zmq_probe = zeromq.pub_sink(gr.sizeof_float, probe_adr)
#self.null_sink = blocks.null_sink(gr.sizeof_float)
# connects
self.connect(self.gr_sig_source, self.mult, self.throttle, self.zmq_sink)
self.connect(self.throttle, self.zmq_probe)
# ZeroMQ
self.rpc_manager = zeromq.rpc_manager()
self.rpc_manager.set_reply_socket(rpc_adr)
self.rpc_manager.add_interface("start_fg",self.start_fg)
self.rpc_manager.add_interface("stop_fg",self.stop_fg)
self.rpc_manager.add_interface("set_waveform",self.set_waveform)
self.rpc_manager.add_interface("set_k",self.mult.set_k)
self.rpc_manager.add_interface("get_sample_rate",self.throttle.sample_rate)
self.rpc_manager.start_watcher()
def get_channels(frequency=220.352e6, rf_gain=25, if_gain=0, bb_gain=0, ppm=0, use_zeromq=False, server="tcp://127.0.0.1:10444", server_control="tcp://127.0.0.1:10445"):
from gnuradio import gr, blocks, audio
if use_zeromq:
from gnuradio import zeromq
import osmosdr
import grdab
import time
samp_rate = samp_rate = 2000000
print("Setting frequency: %0.3f MHz" % (frequency/1e6))
if not use_zeromq:
osmosdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + '' )
osmosdr_source_0.set_sample_rate(samp_rate)
osmosdr_source_0.set_center_freq(frequency, 0)
osmosdr_source_0.set_freq_corr(0, 0)
osmosdr_source_0.set_dc_offset_mode(0, 0)
osmosdr_source_0.set_iq_balance_mode(0, 0)
osmosdr_source_0.set_gain_mode(False, 0)
osmosdr_source_0.set_gain(rf_gain, 0)
osmosdr_source_0.set_if_gain(if_gain, 0)
osmosdr_source_0.set_bb_gain(bb_gain, 0)
osmosdr_source_0.set_antenna('RX2', 0)
osmosdr_source_0.set_bandwidth(2000000, 0)
else:
zeromq_source = zeromq.sub_source(gr.sizeof_gr_complex, 1, server, 100, False, -1)
rpc_mgr_server = zeromq.rpc_manager()
rpc_mgr_server.set_request_socket(server_control)
rpc_mgr_server.request("set_sample_rate",[samp_rate])
rpc_mgr_server.request("set_rf_gain",[rf_gain])
rpc_mgr_server.request("set_if_gain",[if_gain])
rpc_mgr_server.request("set_bb_gain",[bb_gain])
rpc_mgr_server.request("set_ppm",[0]) # Not using hardware correction since it behaves differently on different hardware
rpc_mgr_server.request("set_frequency",[frequency])
time.sleep(0.7)
sample_rate_correction_factor = 1 + float(ppm)*1e-6
dab_ofdm_demod_0 = grdab.ofdm_demod(
grdab.parameters.dab_parameters(
mode=1,
sample_rate=samp_rate,
verbose=False
),
grdab.parameters.receiver_parameters(
mode=1,
softbits=True,
input_fft_filter=True,
autocorrect_sample_rate=False,
sample_rate_correction_factor=sample_rate_correction_factor,
always_include_resample=True,
verbose=False,
correct_ffe=True,
equalize_magnitude=True
)
)
dab_fic_decode_0 = grdab.fic_decode(
grdab.parameters.dab_parameters(
mode=1,
sample_rate=samp_rate,
verbose=False
)
)
#dab_fic_decode_0.set_print_channel_info(True)
fg = gr.top_block()
if not use_zeromq:
fg.connect(osmosdr_source_0, dab_ofdm_demod_0)
else:
fg.connect(zeromq_source, dab_ofdm_demod_0)
fg.connect(dab_ofdm_demod_0, dab_fic_decode_0)
fg.start()
attempt = 0
maxattempts = 9
channels = {}
while True:
service_labels = dab_fic_decode_0.get_service_labels()
if service_labels.strip() != "":
service_labels_json = json.loads(service_labels.strip())
for s in service_labels_json:
if s['reference'] not in channels:
channels[s['reference']] = {}
channels[s['reference']]['label'] = s['label']
subch_info = dab_fic_decode_0.get_subch_info()
service_info = dab_fic_decode_0.get_service_info() # mapping between service_labels number and subch_info number
if service_info.strip() != "":
service_info_json = json.loads(service_info.strip())
for s in service_info_json:
if s['reference'] not in channels:
channels[s['reference']] = {}
channels[s['reference']]['id'] = s['ID']
channels[s['reference']]['dabplus'] = s['DAB+']
subch_info = dab_fic_decode_0.get_subch_info() # settings needed for setting channel
if subch_info.strip() != "":
subch_info_json = json.loads(subch_info.strip())
for s in subch_info_json:
if 'ID' in s:
current_id = s['ID']
for key,val in channels.items():
if 'id' in val:
if val['id'] == current_id:
channels[key]['subch_info'] = s
break
all_have_label = True
for c,item in channels.items():
if 'label' not in item:
all_have_label = False
if attempt == maxattempts-1:
all_have_label = True
complete = False
if len(channels) > 0 and all_have_label:
print("Channels:")
for c,item in channels.items():
if 'subch_info' in item:
conv_table = [ 128, 8, 6, 5];
protect_level = item['subch_info']['protection']
subch_size = item['subch_info']['size']
if protect_level <= 4:
if 'label' in item:
label = item['label']
else:
label = "UNKNOWN"
bit_rate = subch_size * 8 / (conv_table[protect_level]);
print("%s: (address: %3d, subch_size: %3d, protect_level: %1d, bit_rate: %3d, classic: %1d)" % (label, item['subch_info']['address'], item['subch_info']['size'], item['subch_info']['protection'], bit_rate, not item['dabplus']))
complete = True
if complete:
break
attempt = attempt + 1
time.sleep(1)
fg.stop()
def get_channels(frequency=220.352e6,
rf_gain=25,
if_gain=0,
bb_gain=0,
ppm=0,
use_zeromq=False,
server="tcp://127.0.0.1:10444",
server_control="tcp://127.0.0.1:10445",
from_file=None,
from_file_repeat=False):
from gnuradio import gr, blocks, audio
if use_zeromq:
from gnuradio import zeromq
import osmosdr
import grdab
import time
samp_rate = samp_rate = 2048000
print("Setting frequency: %0.3f MHz" % (frequency / 1e6))
fg = gr.top_block()
if from_file != None:
file_input = blocks.file_source(gr.sizeof_gr_complex, from_file,
True) # Makes sense to always repeat
src = file_input
print("Run from file %s" % from_file)
elif not use_zeromq:
osmosdr_source_0 = osmosdr.source(args="numchan=" + str(1) + " " + '')
osmosdr_source_0.set_sample_rate(samp_rate)
osmosdr_source_0.set_center_freq(frequency, 0)
osmosdr_source_0.set_freq_corr(0, 0)
osmosdr_source_0.set_dc_offset_mode(0, 0)
osmosdr_source_0.set_iq_balance_mode(0, 0)
osmosdr_source_0.set_gain_mode(False, 0)
osmosdr_source_0.set_gain(rf_gain, 0)
osmosdr_source_0.set_if_gain(if_gain, 0)
osmosdr_source_0.set_bb_gain(bb_gain, 0)
osmosdr_source_0.set_antenna('RX2', 0)
osmosdr_source_0.set_bandwidth(2000000, 0)
src = osmosdr_source_0
else:
zeromq_source = zeromq.sub_source(gr.sizeof_gr_complex, 1, server, 100,
False, -1)
rpc_mgr_server = zeromq.rpc_manager()
rpc_mgr_server.set_request_socket(server_control)
rpc_mgr_server.request("set_sample_rate", [samp_rate])
rpc_mgr_server.request("set_rf_gain", [rf_gain])
rpc_mgr_server.request("set_if_gain", [if_gain])
rpc_mgr_server.request("set_bb_gain", [bb_gain])
rpc_mgr_server.request(
"set_ppm", [0]
) # Not using hardware correction since it behaves differently on different hardware
rpc_mgr_server.request("set_frequency", [frequency])
time.sleep(0.7)
src = zeromq_source
sample_rate_correction_factor = 1 + float(ppm) * 1e-6
dab_ofdm_demod_0 = grdab.ofdm_demod(
grdab.parameters.dab_parameters(mode=1,
sample_rate=samp_rate,
verbose=False),
grdab.parameters.receiver_parameters(
mode=1,
softbits=True,
input_fft_filter=True,
autocorrect_sample_rate=False,
sample_rate_correction_factor=sample_rate_correction_factor,
always_include_resample=True,
verbose=False,
correct_ffe=True,
equalize_magnitude=True))
dab_fic_decode_0 = grdab.fic_decode(
grdab.parameters.dab_parameters(mode=1,
sample_rate=samp_rate,
verbose=False))
#dab_fic_decode_0.set_print_channel_info(True)
fg.connect(src, dab_ofdm_demod_0)
fg.connect(dab_ofdm_demod_0, dab_fic_decode_0)
fg.start()
attempt = 0
maxattempts = 9
channels = {}
while True:
service_labels = dab_fic_decode_0.get_service_labels()
if service_labels.strip() != "":
service_labels_json = json.loads(service_labels.strip())
for s in service_labels_json:
if s['reference'] not in channels:
channels[s['reference']] = {}
channels[s['reference']]['label'] = s['label']
subch_info = dab_fic_decode_0.get_subch_info()
service_info = dab_fic_decode_0.get_service_info(
) # mapping between service_labels number and subch_info number
if service_info.strip() != "":
service_info_json = json.loads(service_info.strip())
for s in service_info_json:
if s['reference'] not in channels:
channels[s['reference']] = {}
channels[s['reference']]['id'] = s['ID']
channels[s['reference']]['dabplus'] = s['DAB+']
subch_info = dab_fic_decode_0.get_subch_info(
) # settings needed for setting channel
if subch_info.strip() != "":
subch_info_json = json.loads(subch_info.strip())
for s in subch_info_json:
if 'ID' in s:
current_id = s['ID']
for key, val in channels.items():
if 'id' in val:
if val['id'] == current_id:
channels[key]['subch_info'] = s
break
all_have_label = True
for c, item in channels.items():
if 'label' not in item:
all_have_label = False
if attempt == maxattempts - 1:
all_have_label = True
complete = False
if len(channels) > 0 and all_have_label:
print("Channels:")
for c, item in channels.items():
if 'subch_info' in item:
conv_table = [128, 8, 6, 5]
protect_level = item['subch_info']['protection']
subch_size = item['subch_info']['size']
if protect_level <= 4:
if 'label' in item:
label = item['label']
else:
label = "UNKNOWN"
bit_rate = subch_size * 8 / (conv_table[protect_level])
print(
"%s: (address: %3d, subch_size: %3d, protect_level: %1d, bit_rate: %3d, classic: %1d)"
% (label, item['subch_info']['address'],
item['subch_info']['size'],
item['subch_info']['protection'], bit_rate,
not item['dabplus']))
complete = True
if complete:
break
attempt = attempt + 1
time.sleep(1)
fg.stop()
def __init__(self, options, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.options = options
# load and uic the file right away, no additional step necessary
self.gui = uic.loadUi(os.path.join(os.path.dirname(__file__),'ofdm_tx_gui_window.ui'), self)
# GUI update timer
self.plot_timer = Qt.QTimer()
# ZeroMQ
self.probe_manager = zeromq.probe_manager()
self.probe_manager.add_socket("tcp://"+self.options.tx_hostname+":4444", 'f', self.plot_powerallocation)
self.probe_manager.add_socket("tcp://"+self.options.tx_hostname+":4445", 'B', self.plot_bitloading)
self.rpc_mgr_tx = zeromq.rpc_manager()
self.rpc_mgr_tx.set_request_socket("tcp://"+self.options.tx_hostname+":6660")
# Window Title
self.gui.setWindowTitle("Transmitter")
#Plots
self.gui.qwtPlotPowerallocation.setTitle("Subcarrier Power Allocation")
self.gui.qwtPlotPowerallocation.setAxisTitle(Qwt.QwtPlot.xBottom, "Subcarrier Index")
self.gui.qwtPlotPowerallocation.setAxisScale(Qwt.QwtPlot.xBottom, -99, 100)
self.gui.qwtPlotPowerallocation.setAxisScale(Qwt.QwtPlot.yLeft, 0, 3)
self.gui.qwtPlotPowerallocation.setCanvasBackground(Qt.Qt.white)
self.grid_powerallocation = Qwt.QwtPlotGrid()
self.grid_powerallocation.enableXMin(True)
self.grid_powerallocation.setPen(Qt.QPen(Qt.Qt.black, 1, Qt.Qt.DotLine))
self.grid_powerallocation.attach(self.gui.qwtPlotPowerallocation)
self.powerallocation_x = range(-99,101)
self.powerallocation_y = [0]*len(self.powerallocation_x)
self.curve_powerallocation = Qwt.QwtPlotCurve()
self.curve_powerallocation.setPen(Qt.QPen(Qt.Qt.green, 1))
self.curve_powerallocation.setBrush(Qt.Qt.green)
self.curve_powerallocation.setStyle(Qwt.QwtPlotCurve.Steps)
self.curve_powerallocation.attach(self.gui.qwtPlotPowerallocation)
self.gui.qwtPlotBitloading.setTitle("Subcarrier Bitloading")
self.gui.qwtPlotBitloading.setAxisTitle(Qwt.QwtPlot.xBottom, "Subcarrier Index")
self.gui.qwtPlotBitloading.setAxisScale(Qwt.QwtPlot.xBottom, -99, 100)
self.gui.qwtPlotBitloading.setAxisScale(Qwt.QwtPlot.yLeft, 0, 8)
self.gui.qwtPlotBitloading.setCanvasBackground(Qt.Qt.white)
self.grid_bitloading = Qwt.QwtPlotGrid()
self.grid_bitloading.enableXMin(True)
self.grid_bitloading.setPen(Qt.QPen(Qt.Qt.black, 1, Qt.Qt.DotLine))
self.grid_bitloading.attach(self.gui.qwtPlotBitloading)
self.bitloading_x = range(-99,101)
self.bitloading_y = [0]*len(self.bitloading_x)
self.curve_bitloading = Qwt.QwtPlotCurve()
self.curve_bitloading.setPen(Qt.QPen(Qt.Qt.magenta, 1))
self.curve_bitloading.setBrush(Qt.Qt.magenta)
self.curve_bitloading.setStyle(Qwt.QwtPlotCurve.Steps)
self.curve_bitloading.attach(self.gui.qwtPlotBitloading)
#Signals
self.connect(self.plot_timer, QtCore.SIGNAL("timeout()"), self.probe_manager.watcher)
self.connect(self.gui.pushButtonUpdate, QtCore.SIGNAL("clicked()"), self.update_tx_parameters)
# start GUI update timer (33ms for 30 FPS)
self.plot_timer.start(33)
def main(rf_gain, if_gain, bb_gain, ppm, use_zeromq_in=False, server="tcp://127.0.0.1:10444", server_control="tcp://127.0.0.1:10445"):
global src
global decoder
global dab_ofdm_demod_0
global c2f
global f2c
global audio_sink_0
global fg
global xrun_monitor
global use_zeromq
global rpc_mgr_server
global dab_ofdm_demod_0
global ppm_shared
frequency=220.352e6
audio_sample_rate=48000
ppm_shared = ppm
dab_bit_rate=64
dab_address=304
dab_subch_size=64
dab_protect_level=1
use_zeromq=use_zeromq_in
if use_zeromq:
from gnuradio import zeromq
else:
import osmosdr
import time
if len(channel_list) > 0:
ch = channel_list[0]
frequency = float(ch['frequency'])*1e6
else:
ch = {"bit_rate" : 64, "address" : 304, "subch_size" : 64, "protect_level" : 1}
print("Setting frequency: %0.3f MHz" % (frequency/1e6))
if not use_zeromq:
osmosdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + '' )
osmosdr_source_0.set_sample_rate(samp_rate)
osmosdr_source_0.set_center_freq(frequency, 0)
osmosdr_source_0.set_freq_corr(0, 0)
osmosdr_source_0.set_dc_offset_mode(0, 0)
osmosdr_source_0.set_iq_balance_mode(0, 0)
osmosdr_source_0.set_gain_mode(False, 0)
osmosdr_source_0.set_gain(rf_gain, 0)
osmosdr_source_0.set_if_gain(if_gain, 0)
osmosdr_source_0.set_bb_gain(bb_gain, 0)
osmosdr_source_0.set_antenna('RX2', 0)
osmosdr_source_0.set_bandwidth(2000000, 0)
else:
zeromq_source = zeromq.sub_source(gr.sizeof_gr_complex, 1, server, 100, False, -1)
rpc_mgr_server = zeromq.rpc_manager()
rpc_mgr_server.set_request_socket(server_control)
rpc_mgr_server.request("set_sample_rate",[samp_rate])
rpc_mgr_server.request("set_rf_gain",[rf_gain])
rpc_mgr_server.request("set_if_gain",[if_gain])
rpc_mgr_server.request("set_bb_gain",[bb_gain])
rpc_mgr_server.request("set_ppm",[0]) # Not using hardware correction since it behaves differently on different hardware
rpc_mgr_server.request("set_frequency",[frequency])
time.sleep(0.7)
sample_rate_correction_factor = 1 + float(ppm_shared)*1e-6
dab_ofdm_demod_0 = grdab.ofdm_demod(
grdab.parameters.dab_parameters(
mode=1,
sample_rate=samp_rate,
verbose=False
),
grdab.parameters.receiver_parameters(
mode=1,
softbits=True,
input_fft_filter=True,
autocorrect_sample_rate=False,
sample_rate_correction_factor=sample_rate_correction_factor,
always_include_resample=True,
verbose=False,
correct_ffe=True,
equalize_magnitude=True
)
)
if 'classic' in ch and ch['classic'] == True:
dabplus = False
else:
dabplus = True
if dabplus:
decoder = grdab.dabplus_audio_decoder_ff(grdab.parameters.dab_parameters(mode=1, sample_rate=samp_rate, verbose=False), ch['bit_rate'], ch['address'], ch['subch_size'], ch['protect_level'], True)
else:
decoder = grdab.dab_audio_decoder_ff(grdab.parameters.dab_parameters(mode=1, sample_rate=samp_rate, verbose=False), ch['bit_rate'], ch['address'], ch['subch_size'], ch['protect_level'], True)
xrun_monitor = grdab.xrun_monitor_cc(100000)
xrun_monitor.set_report_fill(False)
f2c = blocks.float_to_complex()
c2f = blocks.complex_to_float()
audio_sink_0 = audio.sink(audio_sample_rate, '', True)
fg = gr.top_block()
if not use_zeromq:
src = osmosdr_source_0
else:
src = zeromq_source
fg.connect(src, dab_ofdm_demod_0, decoder)
fg.connect((decoder, 0), (f2c, 0))
fg.connect((decoder, 1), (f2c, 1))
fg.connect(f2c, xrun_monitor)
fg.connect(xrun_monitor, c2f)
fg.connect((c2f, 0), (audio_sink_0, 0))
fg.connect((c2f, 1), (audio_sink_0, 1))
fg.start()
curses.wrapper(draw_menu)
def __init__(self, options, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.options = options
# load and uic the file right away, no additional step necessary
self.gui = uic.loadUi(os.path.join(os.path.dirname(__file__),'ofdm_rx_gui_window.ui'), self)
# GUI update timer
self.update_timer = Qt.QTimer()
# ZeroMQ
self.probe_manager = zeromq.probe_manager()
self.probe_manager.add_socket("tcp://"+self.options.rx_hostname+":5555", 'float32', self.plot_snr)
self.probe_manager.add_socket("tcp://"+self.options.rx_hostname+":5556", 'float32', self.plot_ber)
if options.measurement:
self.probe_manager.add_socket("tcp://"+self.options.rx_hostname+":5556", 'float32', self.take_measurement)
self.probe_manager.add_socket("tcp://"+self.options.rx_hostname+":5557", 'float32', self.plot_freqoffset)
self.probe_manager.add_socket("tcp://"+self.options.tx_hostname+":4445", 'uint8', self.plot_rate)
self.probe_manager.add_socket("tcp://"+self.options.rx_hostname+":5559", 'float32', self.plot_csi)
self.probe_manager.add_socket("tcp://"+self.options.rx_hostname+":5560", 'complex64', self.plot_scatter)
self.rpc_mgr_tx = zeromq.rpc_manager()
self.rpc_mgr_tx.set_request_socket("tcp://"+self.options.tx_hostname+":6660")
self.rpc_mgr_rx = zeromq.rpc_manager()
self.rpc_mgr_rx.set_request_socket("tcp://"+self.options.rx_hostname+":5550")
# Window Title
self.gui.setWindowTitle("Receiver")
#Plots
self.gui.qwtPlotSNR.setAxisTitle(Qwt.QwtPlot.yLeft, "SNR[dB]")
self.gui.qwtPlotSNR.setAxisScale(Qwt.QwtPlot.xBottom, 0, 127)
self.gui.qwtPlotSNR.enableAxis(Qwt.QwtPlot.xBottom, False)
self.gui.qwtPlotSNR.setAxisScale(Qwt.QwtPlot.yLeft, 0, 30)
self.gui.qwtPlotSNR.setCanvasBackground(Qt.Qt.white)
self.grid_snr = Qwt.QwtPlotGrid()
self.grid_snr.setPen(Qt.QPen(Qt.Qt.black, 1, Qt.Qt.DotLine))
self.grid_snr.attach(self.gui.qwtPlotSNR)
self.snr_x = range(0,128)
self.snr_y = [0.0]
self.curve_snr = Qwt.QwtPlotCurve()
self.curve_snr.setPen(Qt.QPen(Qt.Qt.red, 1))
self.curve_snr.setBrush(Qt.Qt.red)
self.curve_snr.setStyle(Qwt.QwtPlotCurve.Steps)
self.curve_snr.attach(self.gui.qwtPlotSNR)
self.gui.qwtPlotBER.setAxisTitle(Qwt.QwtPlot.yLeft, "BER")
self.gui.qwtPlotBER.setAxisScale(Qwt.QwtPlot.xBottom, 0, 127)
self.gui.qwtPlotBER.enableAxis(Qwt.QwtPlot.xBottom, False)
self.gui.qwtPlotBER.setAxisScale(Qwt.QwtPlot.yLeft, 0.0001, 0.5)
self.gui.qwtPlotBER.setCanvasBackground(Qt.Qt.white)
self.grid_ber = Qwt.QwtPlotGrid()
self.grid_ber.setPen(Qt.QPen(Qt.Qt.black, 1, Qt.Qt.DotLine))
self.grid_ber.attach(self.gui.qwtPlotBER)
scale_engine = Qwt.QwtLog10ScaleEngine()
self.gui.qwtPlotBER.setAxisScaleEngine(Qwt.QwtPlot.yLeft, scale_engine)
self.ber_x = range(0,128)
self.ber_y = [0.0]
self.curve_ber = Qwt.QwtPlotCurve()
self.curve_ber.setBaseline(1e-100)
self.curve_ber.setPen(Qt.QPen(Qt.Qt.green, 1))
self.curve_ber.setBrush(Qt.Qt.green)
self.curve_ber.setStyle(Qwt.QwtPlotCurve.Steps)
self.curve_ber.attach(self.gui.qwtPlotBER)
self.gui.qwtPlotFreqoffset.setAxisTitle(Qwt.QwtPlot.yLeft, "Frequency Offset")
self.gui.qwtPlotFreqoffset.setAxisScale(Qwt.QwtPlot.xBottom, 0, 127)
self.gui.qwtPlotFreqoffset.enableAxis(Qwt.QwtPlot.xBottom, False)
self.gui.qwtPlotFreqoffset.setAxisScale(Qwt.QwtPlot.yLeft, -1, 1)
self.gui.qwtPlotFreqoffset.setCanvasBackground(Qt.Qt.white)
self.grid_freqoffset = Qwt.QwtPlotGrid()
self.grid_freqoffset.setPen(Qt.QPen(Qt.Qt.black, 1, Qt.Qt.DotLine))
self.grid_freqoffset.attach(self.gui.qwtPlotFreqoffset)
self.freqoffset_x = range(0,128)
self.freqoffset_y = [0.0]
self.curve_freqoffset = Qwt.QwtPlotCurve()
self.curve_freqoffset.setPen(Qt.QPen(Qt.Qt.black, 1))
self.curve_freqoffset.attach(self.gui.qwtPlotFreqoffset)
self.gui.qwtPlotRate.setAxisTitle(Qwt.QwtPlot.yLeft, "Datarate[Mbits/s]")
self.gui.qwtPlotRate.setAxisScale(Qwt.QwtPlot.xBottom, 0, 127)
self.gui.qwtPlotRate.enableAxis(Qwt.QwtPlot.xBottom, False)
self.gui.qwtPlotRate.setAxisScale(Qwt.QwtPlot.yLeft, 0, 10)
self.gui.qwtPlotRate.setCanvasBackground(Qt.Qt.white)
self.grid_rate = Qwt.QwtPlotGrid()
self.grid_rate.setPen(Qt.QPen(Qt.Qt.black, 1, Qt.Qt.DotLine))
self.grid_rate.attach(self.gui.qwtPlotRate)
self.rate_x = range(0,128)
self.rate_y = [0]*len(self.rate_x)
self.curve_rate = Qwt.QwtPlotCurve()
self.curve_rate.setPen(Qt.QPen(Qt.Qt.lightGray, 1))
self.curve_rate.setBrush(Qt.Qt.lightGray)
self.curve_rate.setStyle(Qwt.QwtPlotCurve.Steps)
self.curve_rate.attach(self.gui.qwtPlotRate)
self.gui.qwtPlotCSI.setTitle("Normalized Channel State Information")
self.gui.qwtPlotCSI.setAxisTitle(Qwt.QwtPlot.xBottom, "Subcarrier")
self.gui.qwtPlotCSI.setAxisScale(Qwt.QwtPlot.xBottom, -99, 100)
self.gui.qwtPlotCSI.setAxisScale(Qwt.QwtPlot.yLeft, 0, 2)
self.gui.qwtPlotCSI.setCanvasBackground(Qt.Qt.white)
self.grid_csi = Qwt.QwtPlotGrid()
self.grid_csi.enableXMin(True)
self.grid_csi.setPen(Qt.QPen(Qt.Qt.black, 1, Qt.Qt.DotLine))
self.grid_csi.attach(self.gui.qwtPlotCSI)
self.csi_x = range(-99,101)
self.csi_y = [0]*len(self.csi_x)
self.curve_csi = Qwt.QwtPlotCurve()
self.curve_csi.setPen(Qt.QPen(Qt.Qt.blue, 1))
self.curve_csi.setBrush(Qt.Qt.blue)
self.curve_csi.setStyle(Qwt.QwtPlotCurve.Steps)
self.curve_csi.attach(self.gui.qwtPlotCSI)
self.gui.qwtPlotScatter.setTitle("Scatterplot (Subcarrier -99)")
self.gui.qwtPlotScatter.setAxisTitle(Qwt.QwtPlot.xBottom, "I")
self.gui.qwtPlotScatter.setAxisTitle(Qwt.QwtPlot.yLeft, "Q")
self.gui.qwtPlotScatter.setAxisScale(Qwt.QwtPlot.xBottom, -1.5, 1.5)
self.gui.qwtPlotScatter.setAxisScale(Qwt.QwtPlot.yLeft, -1.5, 1.5)
self.gui.qwtPlotScatter.setCanvasBackground(Qt.Qt.white)
self.grid_scatter = Qwt.QwtPlotGrid()
self.grid_scatter.setPen(Qt.QPen(Qt.Qt.black, 1, Qt.Qt.DotLine))
self.grid_scatter.attach(self.gui.qwtPlotScatter)
self.scatter_buffer = numpy.complex64([0+0j])
self.curve_scatter = Qwt.QwtPlotCurve()
self.curve_scatter.setPen(Qt.QPen(Qt.Qt.blue, 1))
self.curve_scatter.setStyle(Qwt.QwtPlotCurve.Dots)
self.curve_scatter.attach(self.gui.qwtPlotScatter)
self.marker = Qwt.QwtSymbol()
self.marker.setStyle(Qwt.QwtSymbol.XCross)
self.marker.setSize(Qt.QSize(3,3))
self.curve_scatter.setSymbol(self.marker)
# plot picker
self.plot_picker = Qwt.QwtPlotPicker(Qwt.QwtPlot.xBottom,
Qwt.QwtPlot.yLeft,
Qwt.QwtPicker.PointSelection,
Qwt.QwtPlotPicker.VLineRubberBand,
Qwt.QwtPicker.AlwaysOff,
self.gui.qwtPlotCSI.canvas())
#Signals
self.connect(self.update_timer, QtCore.SIGNAL("timeout()"), self.probe_manager.watcher)
self.connect(self.gui.pushButtonMeasure, QtCore.SIGNAL("clicked()"), self.measure_average)
#self.connect(self.gui.pushButtonUpdate, QtCore.SIGNAL("clicked()"), self.update_modulation)
self.connect(self.gui.horizontalSliderAmplitude, QtCore.SIGNAL("valueChanged(int)"), self.slide_amplitude)
self.connect(self.gui.lineEditAmplitude, QtCore.SIGNAL("editingFinished()"), self.edit_amplitude)
self.connect(self.gui.horizontalSliderOffset, QtCore.SIGNAL("valueChanged(int)"), self.slide_freq_offset)
self.connect(self.gui.lineEditOffset, QtCore.SIGNAL("editingFinished()"), self.edit_freq_offset)
self.connect(self.plot_picker, QtCore.SIGNAL("selected(const QwtDoublePoint &)"), self.subcarrier_selected)
self.connect(self.gui.comboBoxChannelModel, QtCore.SIGNAL("currentIndexChanged(QString)"), self.set_channel_profile)
self.connect(self.gui.horizontalSliderTxGain, QtCore.SIGNAL("valueChanged(int)"), self.slide_tx_gain)
self.connect(self.gui.horizontalSliderRxGain, QtCore.SIGNAL("valueChanged(int)"), self.slide_rx_gain)
self.connect(self.gui.comboBoxScheme, QtCore.SIGNAL("currentIndexChanged(QString)"), self.set_allocation_scheme)
self.connect(self.gui.horizontalSliderDataRate, QtCore.SIGNAL("valueChanged(int)"), self.slide_data_rate)
self.connect(self.gui.lineEditDataRate, QtCore.SIGNAL("editingFinished()"), self.edit_data_rate)
self.connect(self.gui.horizontalSliderGap, QtCore.SIGNAL("valueChanged(int)"), self.slide_target_ber)
self.connect(self.gui.lineEditGap, QtCore.SIGNAL("editingFinished()"), self.edit_target_ber)
self.connect(self.gui.horizontalSliderResourceBlockSize, QtCore.SIGNAL("valueChanged(int)"), self.slide_resource_block_size)
self.connect(self.gui.lineEditResourceBlockSize, QtCore.SIGNAL("editingFinished()"), self.edit_resource_block_size)
self.connect(self.gui.comboBoxResourceBlocksScheme, QtCore.SIGNAL("currentIndexChanged(QString)"), self.set_resource_block_scheme)
self.connect(self.gui.comboBoxModulation, QtCore.SIGNAL("currentIndexChanged(QString)"), self.set_modulation_scheme)
if options.measurement:
self.rpc_mgr_tx.request("set_amplitude",[0.018])
self.rpc_mgr_tx.request("set_amplitude_ideal",[0.018])
self.i = 0
self.ii = 0
self.iii = 1
self.ber=0.0
self.snr=0.0
self.snrsum=0.0
self.datarate=0.0
self.ratesum=0.0
self.dirname = "Simulation_"+strftime("%Y_%m_%d_%H_%M_%S",gmtime())+"/"
print self.dirname
if not os.path.isdir("./" + self.dirname):
os.mkdir("./" + self.dirname + "/")
self.iter_points = 60
self.snr_points = 30
amp_min_log = numpy.log10(0.018**2)
amp_max_log = numpy.log10(0.7**2)
self.txpow_range = numpy.logspace(amp_min_log,amp_max_log,self.snr_points)
self.meas_ber = 0.5
self.change_mod = 1
# start GUI update timer (33ms for 30 FPS)
self.update_timer.start(33)
# get transmitter settings
self.update_tx_params()
def __init__(self, window_name, options, parent=None):
QtGui.QMainWindow.__init__(self, parent)
# give Ctrl+C back to system
signal.signal(signal.SIGINT, signal.SIG_DFL)
self.gui = uic.loadUi(
os.path.join(os.path.dirname(__file__), 'main_window.ui'), self)
self.update_timer = Qt.QTimer()
# socket addresses
rpc_adr_server = "tcp://" + options.servername + ":6666"
rpc_adr_client = "tcp://" + options.clientname + ":6667"
probe_adr_server = "tcp://" + options.servername + ":5556"
probe_adr_client = "tcp://" + options.clientname + ":5557"
# ZeroMQ
self.probe_manager = zeromq.probe_manager()
self.probe_manager.add_socket(probe_adr_server, 'float32',
self.plot_data_server)
self.probe_manager.add_socket(probe_adr_client, 'float32',
self.plot_data_client)
self.rpc_mgr_server = zeromq.rpc_manager()
self.rpc_mgr_server.set_request_socket(rpc_adr_server)
self.rpc_mgr_client = zeromq.rpc_manager()
self.rpc_mgr_client.set_request_socket(rpc_adr_client)
self.gui.setWindowTitle(window_name)
self.gui.qwtPlotServer.setTitle("Signal Scope")
self.gui.qwtPlotServer.setAxisTitle(Qwt.QwtPlot.xBottom, "Samples")
self.gui.qwtPlotServer.setAxisTitle(Qwt.QwtPlot.yLeft, "Amplitude")
self.gui.qwtPlotServer.setAxisScale(Qwt.QwtPlot.xBottom, 0, 100)
self.gui.qwtPlotServer.setAxisScale(Qwt.QwtPlot.yLeft, -2, 2)
self.gui.qwtPlotClient.setTitle("Signal Scope")
self.gui.qwtPlotClient.setAxisTitle(Qwt.QwtPlot.xBottom, "Samples")
self.gui.qwtPlotClient.setAxisTitle(Qwt.QwtPlot.yLeft, "Amplitude")
self.gui.qwtPlotClient.setAxisScale(Qwt.QwtPlot.xBottom, 0, 100)
self.gui.qwtPlotClient.setAxisScale(Qwt.QwtPlot.yLeft, -2, 2)
# Grid
pen = Qt.QPen(Qt.Qt.DotLine)
pen.setColor(Qt.Qt.black)
pen.setWidth(0)
grid_server = Qwt.QwtPlotGrid()
grid_client = Qwt.QwtPlotGrid()
grid_server.setPen(pen)
grid_client.setPen(pen)
grid_server.attach(self.gui.qwtPlotServer)
grid_client.attach(self.gui.qwtPlotClient)
#Signals
self.connect(self.update_timer, QtCore.SIGNAL("timeout()"),
self.probe_manager.watcher)
self.connect(self.gui.pushButtonRunServer, QtCore.SIGNAL("clicked()"),
self.start_fg_server)
self.connect(self.gui.pushButtonStopServer, QtCore.SIGNAL("clicked()"),
self.stop_fg_server)
self.connect(self.gui.pushButtonRunClient, QtCore.SIGNAL("clicked()"),
self.start_fg_client)
self.connect(self.gui.pushButtonStopClient, QtCore.SIGNAL("clicked()"),
self.stop_fg_client)
self.connect(self.gui.comboBox,
QtCore.SIGNAL("currentIndexChanged(QString)"),
self.set_waveform)
self.connect(self.gui.spinBox, QtCore.SIGNAL("valueChanged(int)"),
self.set_gain)
self.shortcut_start = QtGui.QShortcut(Qt.QKeySequence("Ctrl+S"),
self.gui)
self.shortcut_stop = QtGui.QShortcut(Qt.QKeySequence("Ctrl+C"),
self.gui)
self.shortcut_exit = QtGui.QShortcut(Qt.QKeySequence("Ctrl+D"),
self.gui)
self.connect(self.shortcut_exit, QtCore.SIGNAL("activated()"),
self.gui.close)
# start update timer
self.update_timer.start(30)
def receive_dabplus(frequency=220.352e6, rf_gain=25, if_gain=0, bb_gain=0, ppm=80, audio_sample_rate=48000, dab_bit_rate=64, dab_address=304, dab_subch_size=64, dab_protect_level=1, use_zeromq=False, dabplus=True, server="tcp://127.0.0.1:10444", server_control="tcp://127.0.0.1:10445"):
from gnuradio import gr, blocks, audio
if use_zeromq:
from gnuradio import zeromq
import time
import osmosdr
import grdab
samp_rate = samp_rate = 2000000
print("Setting frequency: %0.3f MHz" % (frequency/1e6))
print("Setting RF gain to: %d" % rf_gain)
print("Setting Frequency error (ppm) to: %d" % ppm)
if not use_zeromq:
osmosdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + '' )
osmosdr_source_0.set_sample_rate(samp_rate)
osmosdr_source_0.set_center_freq(frequency, 0)
osmosdr_source_0.set_freq_corr(0, 0)
osmosdr_source_0.set_dc_offset_mode(0, 0)
osmosdr_source_0.set_iq_balance_mode(0, 0)
osmosdr_source_0.set_gain_mode(False, 0)
osmosdr_source_0.set_gain(rf_gain, 0)
osmosdr_source_0.set_if_gain(if_gain, 0)
osmosdr_source_0.set_bb_gain(bb_gain, 0)
osmosdr_source_0.set_antenna('RX2', 0)
osmosdr_source_0.set_bandwidth(2000000, 0)
else:
zeromq_source = zeromq.sub_source(gr.sizeof_gr_complex, 1, server, 100, False, -1)
rpc_mgr_server = zeromq.rpc_manager()
rpc_mgr_server.set_request_socket(server_control)
rpc_mgr_server.request("set_sample_rate",[samp_rate])
rpc_mgr_server.request("set_rf_gain",[rf_gain])
rpc_mgr_server.request("set_if_gain",[if_gain])
rpc_mgr_server.request("set_bb_gain",[bb_gain])
rpc_mgr_server.request("set_ppm",[0]) # Not using hardware correction since it behaves differently on different hardware
rpc_mgr_server.request("set_frequency",[frequency])
time.sleep(0.7)
sample_rate_correction_factor = 1 + float(ppm)*1e-6
dab_ofdm_demod_0 = grdab.ofdm_demod(
grdab.parameters.dab_parameters(
mode=1,
sample_rate=samp_rate,
verbose=False
),
grdab.parameters.receiver_parameters(
mode=1,
softbits=True,
input_fft_filter=True,
autocorrect_sample_rate=False,
sample_rate_correction_factor=sample_rate_correction_factor,
always_include_resample=True,
verbose=False,
correct_ffe=True,
equalize_magnitude=True
)
)
if dabplus:
decoder = grdab.dabplus_audio_decoder_ff(grdab.parameters.dab_parameters(mode=1, sample_rate=samp_rate, verbose=False), dab_bit_rate, dab_address, dab_subch_size, dab_protect_level, True)
else:
decoder = grdab.dab_audio_decoder_ff(grdab.parameters.dab_parameters(mode=1, sample_rate=samp_rate, verbose=False), dab_bit_rate, dab_address, dab_subch_size, dab_protect_level, True)
xrun_monitor = grdab.xrun_monitor_cc(100000)
f2c = blocks.float_to_complex()
c2f = blocks.complex_to_float()
audio_sink_0 = audio.sink(audio_sample_rate, '', True)
fg = gr.top_block()
if not use_zeromq:
src = osmosdr_source_0
else:
src = zeromq_source
fg.connect(src, dab_ofdm_demod_0, decoder)
fg.connect((decoder, 0), (f2c, 0))
fg.connect((decoder, 1), (f2c, 1))
fg.connect(f2c, xrun_monitor)
fg.connect(xrun_monitor, c2f)
fg.connect((c2f, 0), (audio_sink_0, 0))
fg.connect((c2f, 1), (audio_sink_0, 1))
fg.start()
raw_input("Running..")
#new = grdab.dabplus_audio_decoder_ff(grdab.parameters.dab_parameters(mode=1, sample_rate=samp_rate, verbose=False), 64, 304, 64, 1, True)
#newaudio = audio.sink(44100, '', True)
fg.stop()
def __init__(self, options, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.options = options
# load and uic the file right away, no additional step necessary
self.gui = uic.loadUi(
os.path.join(os.path.dirname(__file__), 'ofdm_rx_gui_window.ui'),
self)
# GUI update timer
self.update_timer = Qt.QTimer()
# ZeroMQ
self.probe_manager = zeromq.probe_manager()
self.probe_manager.add_socket(
"tcp://" + self.options.rx_hostname + ":5555", 'float32',
self.plot_snr)
self.probe_manager.add_socket(
"tcp://" + self.options.rx_hostname + ":5556", 'float32',
self.plot_ber)
if options.measurement:
self.probe_manager.add_socket(
"tcp://" + self.options.rx_hostname + ":5556", 'float32',
self.take_measurement)
self.probe_manager.add_socket(
"tcp://" + self.options.rx_hostname + ":5557", 'float32',
self.plot_freqoffset)
self.probe_manager.add_socket(
"tcp://" + self.options.tx_hostname + ":4445", 'uint8',
self.plot_rate)
self.probe_manager.add_socket(
"tcp://" + self.options.rx_hostname + ":5559", 'float32',
self.plot_csi)
self.probe_manager.add_socket(
"tcp://" + self.options.rx_hostname + ":5560", 'complex64',
self.plot_scatter)
self.rpc_mgr_tx = zeromq.rpc_manager()
self.rpc_mgr_tx.set_request_socket("tcp://" +
self.options.tx_hostname + ":6660")
self.rpc_mgr_rx = zeromq.rpc_manager()
self.rpc_mgr_rx.set_request_socket("tcp://" +
self.options.rx_hostname + ":5550")
# Window Title
self.gui.setWindowTitle("Receiver")
#Plots
self.gui.qwtPlotSNR.setAxisTitle(Qwt.QwtPlot.yLeft, "SNR[dB]")
self.gui.qwtPlotSNR.setAxisScale(Qwt.QwtPlot.xBottom, 0, 127)
self.gui.qwtPlotSNR.enableAxis(Qwt.QwtPlot.xBottom, False)
self.gui.qwtPlotSNR.setAxisScale(Qwt.QwtPlot.yLeft, 0, 30)
self.snr_x = range(0, 128)
self.snr_y = [0.0]
self.curve_snr = Qwt.QwtPlotCurve()
self.curve_snr.setPen(Qt.QPen(Qt.Qt.red, 1))
self.curve_snr.setBrush(Qt.Qt.red)
self.curve_snr.setStyle(Qwt.QwtPlotCurve.Steps)
self.curve_snr.attach(self.gui.qwtPlotSNR)
self.gui.qwtPlotBER.setAxisTitle(Qwt.QwtPlot.yLeft, "BER")
self.gui.qwtPlotBER.setAxisScale(Qwt.QwtPlot.xBottom, 0, 127)
self.gui.qwtPlotBER.enableAxis(Qwt.QwtPlot.xBottom, False)
self.gui.qwtPlotBER.setAxisScale(Qwt.QwtPlot.yLeft, 0.0001, 0.5)
scale_engine = Qwt.QwtLog10ScaleEngine()
self.gui.qwtPlotBER.setAxisScaleEngine(Qwt.QwtPlot.yLeft, scale_engine)
self.ber_x = range(0, 128)
self.ber_y = [0.0]
self.curve_ber = Qwt.QwtPlotCurve()
self.curve_ber.setBaseline(1e-100)
self.curve_ber.setPen(Qt.QPen(Qt.Qt.green, 1))
self.curve_ber.setBrush(Qt.Qt.green)
self.curve_ber.setStyle(Qwt.QwtPlotCurve.Steps)
self.curve_ber.attach(self.gui.qwtPlotBER)
self.gui.qwtPlotFreqoffset.setAxisTitle(Qwt.QwtPlot.yLeft,
"Frequency Offset")
self.gui.qwtPlotFreqoffset.setAxisScale(Qwt.QwtPlot.xBottom, 0, 127)
self.gui.qwtPlotFreqoffset.enableAxis(Qwt.QwtPlot.xBottom, False)
self.gui.qwtPlotFreqoffset.setAxisScale(Qwt.QwtPlot.yLeft, -1, 1)
self.freqoffset_x = range(0, 128)
self.freqoffset_y = [0.0]
self.curve_freqoffset = Qwt.QwtPlotCurve()
self.curve_freqoffset.setPen(Qt.QPen(Qt.Qt.black, 1))
self.curve_freqoffset.attach(self.gui.qwtPlotFreqoffset)
self.gui.qwtPlotRate.setAxisTitle(Qwt.QwtPlot.yLeft,
"Datarate[Mbits/s]")
self.gui.qwtPlotRate.setAxisScale(Qwt.QwtPlot.xBottom, 0, 127)
self.gui.qwtPlotRate.enableAxis(Qwt.QwtPlot.xBottom, False)
self.gui.qwtPlotRate.setAxisScale(Qwt.QwtPlot.yLeft, 0, 10)
self.rate_x = range(0, 128)
self.rate_y = [0] * len(self.rate_x)
self.curve_rate = Qwt.QwtPlotCurve()
self.curve_rate.setPen(Qt.QPen(Qt.Qt.lightGray, 1))
self.curve_rate.setBrush(Qt.Qt.lightGray)
self.curve_rate.setStyle(Qwt.QwtPlotCurve.Steps)
self.curve_rate.attach(self.gui.qwtPlotRate)
self.gui.qwtPlotCSI.setTitle("Normalized Channel State Information")
self.gui.qwtPlotCSI.setAxisTitle(Qwt.QwtPlot.xBottom, "Subcarrier")
self.gui.qwtPlotCSI.setAxisScale(Qwt.QwtPlot.xBottom, -99, 100)
self.gui.qwtPlotCSI.setAxisScale(Qwt.QwtPlot.yLeft, 0, 2)
self.csi_x = range(-99, 101)
self.csi_y = [0] * len(self.csi_x)
self.curve_csi = Qwt.QwtPlotCurve()
self.curve_csi.setPen(Qt.QPen(Qt.Qt.blue, 1))
self.curve_csi.setBrush(Qt.Qt.blue)
self.curve_csi.setStyle(Qwt.QwtPlotCurve.Steps)
self.curve_csi.attach(self.gui.qwtPlotCSI)
self.gui.qwtPlotScatter.setTitle("Scatterplot (Subcarrier -99)")
self.gui.qwtPlotScatter.setAxisTitle(Qwt.QwtPlot.xBottom, "I")
self.gui.qwtPlotScatter.setAxisTitle(Qwt.QwtPlot.yLeft, "Q")
self.gui.qwtPlotScatter.setAxisScale(Qwt.QwtPlot.xBottom, -1.5, 1.5)
self.gui.qwtPlotScatter.setAxisScale(Qwt.QwtPlot.yLeft, -1.5, 1.5)
self.scatter_buffer = numpy.complex64([0 + 0j])
self.curve_scatter = Qwt.QwtPlotCurve()
self.curve_scatter.setPen(Qt.QPen(Qt.Qt.blue, 1))
self.curve_scatter.setStyle(Qwt.QwtPlotCurve.Dots)
self.curve_scatter.attach(self.gui.qwtPlotScatter)
self.marker = Qwt.QwtSymbol()
self.marker.setStyle(Qwt.QwtSymbol.XCross)
self.marker.setSize(Qt.QSize(3, 3))
self.curve_scatter.setSymbol(self.marker)
# plot picker
self.plot_picker = Qwt.QwtPlotPicker(Qwt.QwtPlot.xBottom,
Qwt.QwtPlot.yLeft,
Qwt.QwtPicker.PointSelection,
Qwt.QwtPlotPicker.VLineRubberBand,
Qwt.QwtPicker.AlwaysOff,
self.gui.qwtPlotCSI.canvas())
#Signals
self.connect(self.update_timer, QtCore.SIGNAL("timeout()"),
self.probe_manager.watcher)
self.connect(self.gui.pushButtonMeasure, QtCore.SIGNAL("clicked()"),
self.measure_average)
#self.connect(self.gui.pushButtonUpdate, QtCore.SIGNAL("clicked()"), self.update_modulation)
self.connect(self.gui.horizontalSliderAmplitude,
QtCore.SIGNAL("valueChanged(int)"), self.slide_amplitude)
self.connect(self.gui.lineEditAmplitude,
QtCore.SIGNAL("editingFinished()"), self.edit_amplitude)
self.connect(self.gui.horizontalSliderOffset,
QtCore.SIGNAL("valueChanged(int)"),
self.slide_freq_offset)
self.connect(self.gui.lineEditOffset,
QtCore.SIGNAL("editingFinished()"), self.edit_freq_offset)
self.connect(self.plot_picker,
QtCore.SIGNAL("selected(const QwtDoublePoint &)"),
self.subcarrier_selected)
self.connect(self.gui.comboBoxChannelModel,
QtCore.SIGNAL("currentIndexChanged(QString)"),
self.set_channel_profile)
self.connect(self.gui.horizontalSliderTxGain,
QtCore.SIGNAL("valueChanged(int)"), self.slide_tx_gain)
self.connect(self.gui.horizontalSliderRxGain,
QtCore.SIGNAL("valueChanged(int)"), self.slide_rx_gain)
self.connect(self.gui.comboBoxScheme,
QtCore.SIGNAL("currentIndexChanged(QString)"),
self.set_allocation_scheme)
self.connect(self.gui.horizontalSliderDataRate,
QtCore.SIGNAL("valueChanged(int)"), self.slide_data_rate)
self.connect(self.gui.lineEditDataRate,
QtCore.SIGNAL("editingFinished()"), self.edit_data_rate)
self.connect(self.gui.horizontalSliderGap,
QtCore.SIGNAL("valueChanged(int)"), self.slide_gap)
self.connect(self.gui.lineEditGap, QtCore.SIGNAL("editingFinished()"),
self.edit_gap)
self.connect(self.gui.horizontalSliderResourceBlockSize,
QtCore.SIGNAL("valueChanged(int)"),
self.slide_resource_block_size)
self.connect(self.gui.lineEditResourceBlockSize,
QtCore.SIGNAL("editingFinished()"),
self.edit_resource_block_size)
self.connect(self.gui.comboBoxResourceBlocksScheme,
QtCore.SIGNAL("currentIndexChanged(QString)"),
self.set_resource_block_scheme)
self.connect(self.gui.comboBoxModulation,
QtCore.SIGNAL("currentIndexChanged(QString)"),
self.set_modulation_scheme)
if options.measurement:
self.rpc_mgr_tx.request("set_amplitude", [0.018])
self.rpc_mgr_tx.request("set_amplitude_ideal", [0.018])
self.i = 0
self.ii = 0
self.iii = 1
self.ber = 0.0
self.snr = 0.0
self.snrsum = 0.0
self.datarate = 0.0
self.ratesum = 0.0
self.dirname = "Simulation_" + strftime("%Y_%m_%d_%H_%M_%S",
gmtime()) + "/"
print self.dirname
if not os.path.isdir("./" + self.dirname):
os.mkdir("./" + self.dirname + "/")
self.iter_points = 60
self.snr_points = 30
amp_min_log = numpy.log10(0.018**2)
amp_max_log = numpy.log10(0.7**2)
self.txpow_range = numpy.logspace(amp_min_log, amp_max_log,
self.snr_points)
self.meas_ber = 0.5
self.change_mod = 1
# start GUI update timer (33ms for 30 FPS)
self.update_timer.start(33)
# get transmitter settings
self.update_tx_params()
def __init__(self, options, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.options = options
# load and uic the file right away, no additional step necessary
self.gui = uic.loadUi(os.path.join(os.path.dirname(__file__),'ofdm_mrrc_rx_gui_window.ui'), self)
# GUI update timer
self.update_timer = Qt.QTimer()
# ZeroMQ
self.probe_manager = zeromq.probe_manager()
self.probe_manager.add_socket("tcp://"+self.options.rx_hostname+":5555", 'float32', self.plot_snr)
self.probe_manager.add_socket("tcp://"+self.options.rx_hostname+":5554", 'float32', self.plot_snr2)
self.probe_manager.add_socket("tcp://"+self.options.rx_hostname+":5556", 'float32', self.plot_ber)
self.probe_manager.add_socket("tcp://"+self.options.rx_hostname+":5557", 'float32', self.plot_freqoffset)
self.probe_manager.add_socket("tcp://"+self.options.rx_hostname+":5553", 'float32', self.plot_freqoffset2)
self.probe_manager.add_socket("tcp://"+self.options.tx_hostname+":4445", 'uint8', self.plot_rate)
self.probe_manager.add_socket("tcp://"+self.options.rx_hostname+":5559", 'float32', self.plot_csi)
self.probe_manager.add_socket("tcp://"+self.options.rx_hostname+":5558", 'float32', self.plot_csi2)
self.probe_manager.add_socket("tcp://"+self.options.rx_hostname+":5560", 'complex64', self.plot_scatter)
self.rpc_mgr_tx = zeromq.rpc_manager()
self.rpc_mgr_tx.set_request_socket("tcp://"+self.options.tx_hostname+":6660")
self.rpc_mgr_rx = zeromq.rpc_manager()
self.rpc_mgr_rx.set_request_socket("tcp://"+self.options.rx_hostname+":5550")
# Window Title
self.gui.setWindowTitle("Receiver")
#Plots
self.gui.qwtPlotSNR.setAxisTitle(Qwt.QwtPlot.yLeft, "Rx 1 SNR[dB]")
self.gui.qwtPlotSNR.setAxisScale(Qwt.QwtPlot.xBottom, 0, 127)
self.gui.qwtPlotSNR.enableAxis(Qwt.QwtPlot.xBottom, False)
self.gui.qwtPlotSNR.setAxisScale(Qwt.QwtPlot.yLeft, 0, 30)
self.snr_x = range(0,128)
self.snr_y = [0.0]
self.curve_snr = Qwt.QwtPlotCurve()
self.curve_snr.setPen(Qt.QPen(Qt.Qt.red, 1))
self.curve_snr.setBrush(Qt.Qt.red)
self.curve_snr.setStyle(Qwt.QwtPlotCurve.Steps)
self.curve_snr.attach(self.gui.qwtPlotSNR)
#Plots
self.gui.qwtPlotSNR2.setAxisTitle(Qwt.QwtPlot.yLeft, "Rx 2 SNR[dB]")
self.gui.qwtPlotSNR2.setAxisScale(Qwt.QwtPlot.xBottom, 0, 127)
self.gui.qwtPlotSNR2.enableAxis(Qwt.QwtPlot.xBottom, False)
self.gui.qwtPlotSNR2.setAxisScale(Qwt.QwtPlot.yLeft, 0, 30)
self.snr2_x = range(0,128)
self.snr2_y = [0.0]
self.curve_snr2 = Qwt.QwtPlotCurve()
self.curve_snr2.setPen(Qt.QPen(Qt.Qt.red, 1))
self.curve_snr2.setBrush(Qt.Qt.red)
self.curve_snr2.setStyle(Qwt.QwtPlotCurve.Steps)
self.curve_snr2.attach(self.gui.qwtPlotSNR2)
self.gui.qwtPlotBER.setAxisTitle(Qwt.QwtPlot.yLeft, "BER")
self.gui.qwtPlotBER.setAxisScale(Qwt.QwtPlot.xBottom, 0, 127)
self.gui.qwtPlotBER.enableAxis(Qwt.QwtPlot.xBottom, False)
self.gui.qwtPlotBER.setAxisScale(Qwt.QwtPlot.yLeft, 0.0001, 0.5)
scale_engine = Qwt.QwtLog10ScaleEngine()
self.gui.qwtPlotBER.setAxisScaleEngine(Qwt.QwtPlot.yLeft, scale_engine)
self.ber_x = range(0,128)
self.ber_y = [0.0]
self.curve_ber = Qwt.QwtPlotCurve()
self.curve_ber.setBaseline(1e-100)
self.curve_ber.setPen(Qt.QPen(Qt.Qt.green, 1))
self.curve_ber.setBrush(Qt.Qt.green)
self.curve_ber.setStyle(Qwt.QwtPlotCurve.Steps)
self.curve_ber.attach(self.gui.qwtPlotBER)
self.gui.qwtPlotFreqoffset.setAxisTitle(Qwt.QwtPlot.yLeft, "RX 1 Frequency Offset")
self.gui.qwtPlotFreqoffset.setAxisScale(Qwt.QwtPlot.xBottom, 0, 127)
self.gui.qwtPlotFreqoffset.enableAxis(Qwt.QwtPlot.xBottom, False)
self.gui.qwtPlotFreqoffset.setAxisScale(Qwt.QwtPlot.yLeft, -1, 1)
self.freqoffset_x = range(0,128)
self.freqoffset_y = [0.0]
self.curve_freqoffset = Qwt.QwtPlotCurve()
self.curve_freqoffset.setPen(Qt.QPen(Qt.Qt.black, 1))
self.curve_freqoffset.attach(self.gui.qwtPlotFreqoffset)
self.gui.qwtPlotFreqoffset2.setAxisTitle(Qwt.QwtPlot.yLeft, "RX 2 Frequency Offset")
self.gui.qwtPlotFreqoffset2.setAxisScale(Qwt.QwtPlot.xBottom, 0, 127)
self.gui.qwtPlotFreqoffset2.enableAxis(Qwt.QwtPlot.xBottom, False)
self.gui.qwtPlotFreqoffset2.setAxisScale(Qwt.QwtPlot.yLeft, -1, 1)
self.freqoffset2_x = range(0,128)
self.freqoffset2_y = [0.0]
self.curve_freqoffset2 = Qwt.QwtPlotCurve()
self.curve_freqoffset2.setPen(Qt.QPen(Qt.Qt.black, 1))
self.curve_freqoffset2.attach(self.gui.qwtPlotFreqoffset2)
self.gui.qwtPlotRate.setAxisTitle(Qwt.QwtPlot.yLeft, "Datarate[Mbits/s]")
self.gui.qwtPlotRate.setAxisScale(Qwt.QwtPlot.xBottom, 0, 127)
self.gui.qwtPlotRate.enableAxis(Qwt.QwtPlot.xBottom, False)
self.gui.qwtPlotRate.setAxisScale(Qwt.QwtPlot.yLeft, 0, 10)
self.rate_x = range(0,128)
self.rate_y = [0]*len(self.rate_x)
self.curve_rate = Qwt.QwtPlotCurve()
self.curve_rate.setPen(Qt.QPen(Qt.Qt.lightGray, 1))
self.curve_rate.setBrush(Qt.Qt.lightGray)
self.curve_rate.setStyle(Qwt.QwtPlotCurve.Steps)
self.curve_rate.attach(self.gui.qwtPlotRate)
self.gui.qwtPlotCSI.setTitle("Rx 1 Normalized CTF")
self.gui.qwtPlotCSI.setAxisTitle(Qwt.QwtPlot.xBottom, "Subcarrier")
self.gui.qwtPlotCSI.setAxisScale(Qwt.QwtPlot.xBottom, -99, 100)
self.gui.qwtPlotCSI.setAxisScale(Qwt.QwtPlot.yLeft, 0, 2)
self.csi_x = range(-99,101)
self.csi_y = [0]*len(self.csi_x)
self.curve_csi = Qwt.QwtPlotCurve()
self.curve_csi.setPen(Qt.QPen(Qt.Qt.blue, 1))
self.curve_csi.setBrush(Qt.Qt.blue)
self.curve_csi.setStyle(Qwt.QwtPlotCurve.Steps)
self.curve_csi.attach(self.gui.qwtPlotCSI)
self.gui.qwtPlotCSI2.setTitle("Rx 2 Normalized CTF")
self.gui.qwtPlotCSI2.setAxisTitle(Qwt.QwtPlot.xBottom, "Subcarrier")
self.gui.qwtPlotCSI2.setAxisScale(Qwt.QwtPlot.xBottom, -99, 100)
self.gui.qwtPlotCSI2.setAxisScale(Qwt.QwtPlot.yLeft, 0, 2)
#self.csi_x = range(-99,101)
#self.csi_y = [0]*len(self.csi_x)
self.curve_csi2 = Qwt.QwtPlotCurve()
self.curve_csi2.setPen(Qt.QPen(Qt.Qt.blue, 1))
self.curve_csi2.setBrush(Qt.Qt.blue)
self.curve_csi2.setStyle(Qwt.QwtPlotCurve.Steps)
self.curve_csi2.attach(self.gui.qwtPlotCSI2)
self.gui.qwtPlotScatter.setTitle("Scatterplot (Subcarrier -99)")
self.gui.qwtPlotScatter.setAxisTitle(Qwt.QwtPlot.xBottom, "I")
self.gui.qwtPlotScatter.setAxisTitle(Qwt.QwtPlot.yLeft, "Q")
self.gui.qwtPlotScatter.setAxisScale(Qwt.QwtPlot.xBottom, -1.5, 1.5)
self.gui.qwtPlotScatter.setAxisScale(Qwt.QwtPlot.yLeft, -1.5, 1.5)
self.scatter_buffer = numpy.complex64([0+0j])
self.curve_scatter = Qwt.QwtPlotCurve()
self.curve_scatter.setPen(Qt.QPen(Qt.Qt.blue, 1))
self.curve_scatter.setStyle(Qwt.QwtPlotCurve.Dots)
self.curve_scatter.attach(self.gui.qwtPlotScatter)
self.marker = Qwt.QwtSymbol()
self.marker.setStyle(Qwt.QwtSymbol.XCross)
self.marker.setSize(Qt.QSize(3,3))
self.curve_scatter.setSymbol(self.marker)
# plot picker
self.plot_picker = Qwt.QwtPlotPicker(Qwt.QwtPlot.xBottom,
Qwt.QwtPlot.yLeft,
Qwt.QwtPicker.PointSelection,
Qwt.QwtPlotPicker.VLineRubberBand,
Qwt.QwtPicker.AlwaysOff,
self.gui.qwtPlotCSI.canvas(),
#self.gui.qwtPlotCSI2.canvas()
)
#Signals
self.connect(self.update_timer, QtCore.SIGNAL("timeout()"), self.probe_manager.watcher)
self.connect(self.gui.pushButtonMeasure, QtCore.SIGNAL("clicked()"), self.measure_average)
self.connect(self.gui.pushButtonUpdate, QtCore.SIGNAL("clicked()"), self.update_modulation)
self.connect(self.gui.horizontalSliderAmplitude, QtCore.SIGNAL("valueChanged(int)"), self.slide_amplitude)
self.connect(self.gui.lineEditAmplitude, QtCore.SIGNAL("editingFinished()"), self.edit_amplitude)
self.connect(self.gui.horizontalSliderOffset, QtCore.SIGNAL("valueChanged(int)"), self.slide_freq_offset)
self.connect(self.gui.lineEditOffset, QtCore.SIGNAL("editingFinished()"), self.edit_freq_offset)
self.connect(self.plot_picker, QtCore.SIGNAL("selected(const QwtDoublePoint &)"), self.subcarrier_selected)
self.connect(self.gui.comboBoxChannelModel, QtCore.SIGNAL("currentIndexChanged(QString)"), self.set_channel_profile)
# start GUI update timer
self.update_timer.start(33)
# get transmitter settings
self.update_tx_params()
def receive_dabplus(frequency=220.352e6,
rf_gain=25,
if_gain=0,
bb_gain=0,
ppm=80,
audio_sample_rate=48000,
dab_bit_rate=64,
dab_address=304,
dab_subch_size=64,
dab_protect_level=1,
use_zeromq=False,
dabplus=True,
server="tcp://127.0.0.1:10444",
server_control="tcp://127.0.0.1:10445",
from_file=None,
from_file_repeat=False,
skip_xrun_monitor=False):
from gnuradio import gr, blocks, audio
if use_zeromq:
from gnuradio import zeromq
import time
import osmosdr
import grdab
samp_rate = samp_rate = 2048000
print("Setting frequency: %0.3f MHz" % (frequency / 1e6))
print("Setting RF gain to: %d" % rf_gain)
print("Setting Frequency error (ppm) to: %d" % ppm)
fg = gr.top_block()
if from_file != None:
file_input = blocks.file_source(gr.sizeof_gr_complex, from_file,
from_file_repeat)
if skip_xrun_monitor:
src = file_input
else:
fthrottle = blocks.throttle(gr.sizeof_gr_complex, samp_rate)
fg.connect(file_input, fthrottle)
src = fthrottle
print("Run from file %s" % from_file)
elif not use_zeromq:
osmosdr_source_0 = osmosdr.source(args="numchan=" + str(1) + " " + '')
osmosdr_source_0.set_sample_rate(samp_rate)
osmosdr_source_0.set_center_freq(frequency, 0)
osmosdr_source_0.set_freq_corr(0, 0)
osmosdr_source_0.set_dc_offset_mode(0, 0)
osmosdr_source_0.set_iq_balance_mode(0, 0)
osmosdr_source_0.set_gain_mode(False, 0)
osmosdr_source_0.set_gain(rf_gain, 0)
osmosdr_source_0.set_if_gain(if_gain, 0)
osmosdr_source_0.set_bb_gain(bb_gain, 0)
osmosdr_source_0.set_antenna('RX2', 0)
osmosdr_source_0.set_bandwidth(2000000, 0)
src = osmosdr_source_0
else:
zeromq_source = zeromq.sub_source(gr.sizeof_gr_complex, 1, server, 100,
False, -1)
rpc_mgr_server = zeromq.rpc_manager()
rpc_mgr_server.set_request_socket(server_control)
rpc_mgr_server.request("set_sample_rate", [samp_rate])
rpc_mgr_server.request("set_rf_gain", [rf_gain])
rpc_mgr_server.request("set_if_gain", [if_gain])
rpc_mgr_server.request("set_bb_gain", [bb_gain])
rpc_mgr_server.request(
"set_ppm", [0]
) # Not using hardware correction since it behaves differently on different hardware
rpc_mgr_server.request("set_frequency", [frequency])
time.sleep(0.7)
src = zeromq_source
sample_rate_correction_factor = 1 + float(ppm) * 1e-6
dab_ofdm_demod_0 = grdab.ofdm_demod(
grdab.parameters.dab_parameters(mode=1,
sample_rate=samp_rate,
verbose=False),
grdab.parameters.receiver_parameters(
mode=1,
softbits=True,
input_fft_filter=True,
autocorrect_sample_rate=False,
sample_rate_correction_factor=sample_rate_correction_factor,
always_include_resample=True,
verbose=False,
correct_ffe=True,
equalize_magnitude=True))
if dabplus:
decoder = grdab.dabplus_audio_decoder_ff(
grdab.parameters.dab_parameters(mode=1,
sample_rate=samp_rate,
verbose=False), dab_bit_rate,
dab_address, dab_subch_size, dab_protect_level, True)
else:
decoder = grdab.dab_audio_decoder_ff(
grdab.parameters.dab_parameters(mode=1,
sample_rate=samp_rate,
verbose=False), dab_bit_rate,
dab_address, dab_subch_size, dab_protect_level, True)
xrun_monitor = grdab.xrun_monitor_cc(100000)
f2c = blocks.float_to_complex()
c2f = blocks.complex_to_float()
audio_sink_0 = audio.sink(audio_sample_rate, '', True)
fg.connect(src, dab_ofdm_demod_0, decoder)
fg.connect((decoder, 0), (f2c, 0))
fg.connect((decoder, 1), (f2c, 1))
if skip_xrun_monitor:
fg.connect(f2c, c2f)
else:
fg.connect(f2c, xrun_monitor)
fg.connect(xrun_monitor, c2f)
fg.connect((c2f, 0), (audio_sink_0, 0))
fg.connect((c2f, 1), (audio_sink_0, 1))
if from_file != None and from_file_repeat == False and skip_xrun_monitor:
fg.run()
else:
fg.start()
input("Running..")
fg.stop()
def __init__(self):
self.rpc_mgr_rx = zeromq.rpc_manager()
self.rpc_mgr_rx.set_reply_socket("tcp://*:5550")
self.rpc_mgr_rx.start_watcher()
def __init__(self, window_name, options, parent=None):
QtGui.QMainWindow.__init__(self, parent)
# give Ctrl+C back to system
signal.signal(signal.SIGINT, signal.SIG_DFL)
self.gui = uic.loadUi(os.path.join(os.path.dirname(__file__),'main_window.ui'), self)
self.update_timer = Qt.QTimer()
# socket addresses
rpc_adr_server = "tcp://"+options.servername+":6666"
rpc_adr_client = "tcp://"+options.clientname+":6667"
probe_adr_server = "tcp://"+options.servername+":5556"
probe_adr_client = "tcp://"+options.clientname+":5557"
# ZeroMQ
self.probe_manager = zeromq.probe_manager()
self.probe_manager.add_socket(probe_adr_server, 'float32', self.plot_data_server)
self.probe_manager.add_socket(probe_adr_client, 'float32', self.plot_data_client)
self.rpc_mgr_server = zeromq.rpc_manager()
self.rpc_mgr_server.set_request_socket(rpc_adr_server)
self.rpc_mgr_client = zeromq.rpc_manager()
self.rpc_mgr_client.set_request_socket(rpc_adr_client)
self.gui.setWindowTitle(window_name)
self.gui.qwtPlotServer.setTitle("Signal Scope")
self.gui.qwtPlotServer.setAxisTitle(Qwt.QwtPlot.xBottom, "Samples")
self.gui.qwtPlotServer.setAxisTitle(Qwt.QwtPlot.yLeft, "Amplitude")
self.gui.qwtPlotServer.setAxisScale(Qwt.QwtPlot.xBottom, 0, 100)
self.gui.qwtPlotServer.setAxisScale(Qwt.QwtPlot.yLeft, -2, 2)
self.gui.qwtPlotClient.setTitle("Signal Scope")
self.gui.qwtPlotClient.setAxisTitle(Qwt.QwtPlot.xBottom, "Samples")
self.gui.qwtPlotClient.setAxisTitle(Qwt.QwtPlot.yLeft, "Amplitude")
self.gui.qwtPlotClient.setAxisScale(Qwt.QwtPlot.xBottom, 0, 100)
self.gui.qwtPlotClient.setAxisScale(Qwt.QwtPlot.yLeft, -2, 2)
# Grid
pen = Qt.QPen(Qt.Qt.DotLine)
pen.setColor(Qt.Qt.black)
pen.setWidth(0)
grid_server = Qwt.QwtPlotGrid()
grid_client = Qwt.QwtPlotGrid()
grid_server.setPen(pen)
grid_client.setPen(pen)
grid_server.attach(self.gui.qwtPlotServer)
grid_client.attach(self.gui.qwtPlotClient)
#Signals
self.connect(self.update_timer, QtCore.SIGNAL("timeout()"), self.probe_manager.watcher)
self.connect(self.gui.pushButtonRunServer, QtCore.SIGNAL("clicked()"), self.start_fg_server)
self.connect(self.gui.pushButtonStopServer, QtCore.SIGNAL("clicked()"), self.stop_fg_server)
self.connect(self.gui.pushButtonRunClient, QtCore.SIGNAL("clicked()"), self.start_fg_client)
self.connect(self.gui.pushButtonStopClient, QtCore.SIGNAL("clicked()"), self.stop_fg_client)
self.connect(self.gui.comboBox, QtCore.SIGNAL("currentIndexChanged(QString)"), self.set_waveform)
self.connect(self.gui.spinBox, QtCore.SIGNAL("valueChanged(int)"), self.set_gain)
self.shortcut_start = QtGui.QShortcut(Qt.QKeySequence("Ctrl+S"), self.gui)
self.shortcut_stop = QtGui.QShortcut(Qt.QKeySequence("Ctrl+C"), self.gui)
self.shortcut_exit = QtGui.QShortcut(Qt.QKeySequence("Ctrl+D"), self.gui)
self.connect(self.shortcut_exit, QtCore.SIGNAL("activated()"), self.gui.close)
# start update timer
self.update_timer.start(30)
