def __init__(self):
gr.sync_block.__init__(
self, name="blockchain_source",
in_sig=None, out_sig=None)
self.message_port_register_out(pmt.intern("utx"))
self.message_port_register_out(pmt.intern("block"))
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
packet = array.array("B", pmt.u8vector_elements(msg))
try:
header = csp_header.CSP(packet[:4])
except ValueError as e:
if self.verbose:
print e
return
if not self.force and not header.crc:
if self.verbose:
print "CRC not used"
self.message_port_pub(pmt.intern('ok'), msg_pmt)
else:
if len(packet) < 8: # bytes CSP header, 4 bytes CRC-32C
if self.verbose:
print "Malformed CSP packet (too short)"
return
crc = crc32c.crc(packet[:-4] if self.include_header else packet[4:-4])
packet_crc = struct.unpack(">I", packet[-4:])[0]
if crc == packet_crc:
if self.verbose:
print "CRC OK"
self.message_port_pub(pmt.intern('ok'), msg_pmt)
else:
if self.verbose:
print "CRC failed"
self.message_port_pub(pmt.intern('fail'), msg_pmt)
def __init__(self, blkname="set_title", prefix="Title: ", parent=None):
gr.sync_block.__init__(self,blkname,[],[])
self.message_port_register_in(pmt.intern("name"));
self.set_msg_handler(pmt.intern("name"), self.handler)
self.prefix = prefix
self.parent = parent
self.n = ""
def test_tag_propagation(self):
N = 10 # Block length
stream_sizes = [1,2,3]
expected_result = N*(stream_sizes[0]*[1,]
+stream_sizes[1]*[2,]
+stream_sizes[2]*[3,])
# check the data
(result, tags) = self.help_stream_tag_propagation(N, stream_sizes)
self.assertFloatTuplesAlmostEqual(expected_result, result, places=6)
# check the tags
expected_tag_offsets_src1 = [sum(stream_sizes)*i for i in range(N)]
expected_tag_offsets_src2 = [stream_sizes[0]
+sum(stream_sizes)*i for i in range(N)]
expected_tag_offsets_src3 = [stream_sizes[0]+stream_sizes[1]
+sum(stream_sizes)*i for i in range(N)]
tags_src1 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src1'))]
tags_src2 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src2'))]
tags_src3 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src3'))]
for i in range(len(expected_tag_offsets_src1)):
self.assertTrue(expected_tag_offsets_src1[i] == tags_src1[i].offset)
for i in range(len(expected_tag_offsets_src2)):
self.assertTrue(expected_tag_offsets_src2[i] == tags_src2[i].offset)
for i in range(len(expected_tag_offsets_src3)):
self.assertTrue(expected_tag_offsets_src3[i] == tags_src3[i].offset)
def __init__(self):
gr.sync_block.__init__(self,
name="gns430_parser",
in_sig=None,
out_sig=None)
self.count = 0
self.message_port_register_out(pmt.intern('out'))
self.buf = ''
self.message_port_register_in(pmt.intern('in'))
self.set_msg_handler(pmt.intern('in'),self.handle_msg)
self.dict2 = {}
self.lat = 0
self.lon = 0
self.alt = 0
self.nav_status = ''
self.track = 0
self.track_error = 0
self.ground_speed = 0
self.distance_to_wpt = 0
self.bearing_to_wpt = 0
self.destination_id = ''
self.desired_track = 0
def __init__(self):
gr.basic_block.__init__(self, name="packetizer_python", in_sig=[], out_sig=[])
self.message_port_register_in(pmt.intern('in'))
self.message_port_register_out(pmt.intern('out'))
self.set_msg_handler(pmt.intern('in'), self.handle_message)
#Max MTU size in bytes the PHY is able to handle
self.max_mtu_size = 250
def handle_msg(self, msg):
if pmt.dict_has_key(msg, pmt.intern(self.len_tag_key)):
packet_len = pmt.to_python(msg)[self.len_tag_key]
msg = pmt.dict_delete(msg, pmt.intern(self.len_tag_key))
msg = pmt.dict_add(msg, pmt.intern(self.len_tag_key), pmt.from_long(packet_len * 8))
self.message_port_pub(self.msg_buf_out, msg)
def test_001_t(self):
tkey = 'packet_len'
tsrc = 'testsrc'
ptkey = pmt.intern(tkey)
ptsrc = pmt.intern(tsrc)
pre_padding = 17
post_padding = 23
tag = gr.tag_utils.python_to_tag((0, ptkey, pmt.from_long(128), ptsrc))
data = np.arange(128) + 1
data = data.astype(np.complex)
ref = np.concatenate((np.zeros(pre_padding, dtype=data.dtype),
data, np.zeros(post_padding, dtype=data.dtype)))
src = blocks.vector_source_c(data, tags=(tag, ))
uut = gfdm.short_burst_shaper(pre_padding, post_padding, tkey)
snk = blocks.vector_sink_c()
# set up fg
self.tb.connect(src, uut, snk)
self.tb.run()
# check data
res = np.array(snk.data())
self.assertComplexTuplesAlmostEqual(ref, res)
def __init__(self, blkname="text_input", label="", *args):
gr.sync_block.__init__(self,blkname,[],[])
QtGui.QGroupBox.__init__(self, *args)
self.filemax = 0;
self.message_port_register_in(pmt.intern("file_range"));
self.message_port_register_out(pmt.intern("range"));
self.lay = QtGui.QGridLayout()
self.setLayout(self.lay)
self.scroll = QtGui.QScrollBar(Qt.Qt.Horizontal)
self.laStart = QtGui.QLabel("Start Sample:")
self.leStart = QtGui.QLineEdit("0")
self.laLen = QtGui.QLabel("Sample Length:")
self.leLen = QtGui.QLineEdit("4096")
self.lay.addWidget(self.scroll, 0, 0, 1, 4)
self.lay.addWidget(self.laStart, 1, 0)
self.lay.addWidget(self.leStart, 1, 1)
self.lay.addWidget(self.laLen, 1, 2)
self.lay.addWidget(self.leLen, 1, 3)
self.leStart.returnPressed.connect(self.box_changed)
self.leLen.returnPressed.connect(self.box_changed)
self.scroll.sliderMoved.connect(self.slider_changed)
self.set_msg_handler(pmt.intern("file_range"), self.set_file_range)
self.box_changed()
self.scroll.setFocusPolicy(QtCore.Qt.StrongFocus)
def __init__(self, channel_count, channel_map):
gr.basic_block.__init__(self,
name="virtual_channel_encoder",
in_sig=None,
out_sig=None)
if len(channel_map) > channel_count:
channel_map = channel_map[:channel_count]
elif channel_count > len(channel_map):
channel_count = len(channel_map) + 1
self.frags = {}
self.frag_age = 128
self.channel_count = channel_count
self.channel_map = {}
for i in range(channel_count):
out_name = 'out%d' % (i)
if i < len(channel_map):
self.channel_map[channel_map[i]] = out_name
#print "[%s] Registered '%s'" % (self.name, out_name)
self.message_port_register_out(pmt.intern(out_name))
self.message_port_register_in(pmt.intern('in'))
self.set_msg_handler(pmt.intern('in'), self.demux)
def tx_work(self,x):
pygame.init()
screen = pygame.display.set_mode((640, 480))
pygame.display.set_caption('Pygame Caption')
pygame.mouse.set_visible(0)
done = False
while not done:
time.sleep(0.1)
for event in pygame.event.get():
if (event.type == KEYUP) or (event.type == KEYDOWN):
print event
if (event.key == K_ESCAPE and event.type == KEYDOWN):
dict2 = { "id" : "joystick",
"buttons" : [1,0,0]}
#pmt_dict = pmt.to_pmt(dict2)
self.message_port_pub(pmt.intern('out'),pmt.to_pmt(dict2))
if (event.key == K_ESCAPE and event.type == KEYUP):
dict2 = { "id" : "joystick",
"buttons" : [0,0,0]}
#pmt_dict = pmt.to_pmt(dict2)
self.message_port_pub(pmt.intern('out'),pmt.to_pmt(dict2))
print 'here'
'''
def handle_queue(self):
if self.state == self.STATE_IDLE:
if self.app_queue.empty() == False:
self.last_tx_packet = self.app_queue.get()
msg_str = "".join([chr(x) for x in pmt.u8vector_elements(pmt.cdr(self.last_tx_packet))])
self.curr_packet_len = len(msg_str[3:])
self.curr_packet_seq = ord(msg_str[0])
self.last_tx_time = time.time()
print '[stop_and_wait] :: Sending packet. Payload len: '+ str(self.curr_packet_len) +' Queue fill level = ', self.app_queue.qsize()
if self.use_ack:
self.state = self.STATE_WAIT_FOR_ACK
self.num_data_packets_send += 1
self.log_packet("TX", 0, self.curr_packet_len, self.curr_packet_seq, self.last_snr)
self.message_port_pub(pmt.intern('to_phy'), self.last_tx_packet)
elif self.state == self.STATE_WAIT_FOR_ACK:
if (time.time() - self.last_tx_time) > self.ack_timeout:
#retransmit
print '[stop_and_wait] :: ACK timeout. Retransmitting'
self.last_tx_time = time.time()
self.num_ack_timeouts += 1
self.num_data_packets_send += 1
self.log_packet("TX", 0, self.curr_packet_len, self.curr_packet_seq, self.last_snr)
self.message_port_pub(pmt.intern('to_phy'), self.last_tx_packet)
def test_sc_tag(self):
constA = [-3.0+1j, -1.0-1j, 1.0+1j, 3-1j]
constB = [12.0+1j, -12.0-1j, 6.0+1j, -6-1j]
src_data = (0, 1, 2, 3, 3, 2, 1, 0)
expected_result = (-3+1j, -1-1j, 1+1j, 3-1j,
-6-1j, 6+1j, -12-1j, 12+1j)
first_tag = gr.tag_t()
first_tag.key = pmt.intern("set_symbol_table")
first_tag.value = pmt.init_c32vector(len(constA), constA)
first_tag.offset = 0
second_tag = gr.tag_t()
second_tag.key = pmt.intern("set_symbol_table")
second_tag.value = pmt.init_c32vector(len(constB), constB)
second_tag.offset = 4
src = blocks.vector_source_s(src_data, False, 1, [first_tag, second_tag])
op = digital.chunks_to_symbols_sc(constB)
dst = blocks.vector_sink_c()
self.tb.connect(src, op)
self.tb.connect(op, dst)
self.tb.run()
actual_result = dst.data()
self.assertEqual(expected_result, actual_result)
def __init__(self, key):
gr.sync_block.__init__(self,"pdu_meta_extract",[],[])
self.key = key;
self.outport = pmt.intern("values");
self.message_port_register_in(pmt.intern("pdus"));
self.message_port_register_out(self.outport);
self.set_msg_handler(pmt.intern("pdus"), self.handler);
def write_data(self, msg):
snr = pmt.to_double(pmt.dict_ref(msg, pmt.intern("snr"), pmt.from_double(0)))
encoding = pmt.to_long(pmt.dict_ref(msg, pmt.intern("encoding"), pmt.from_long(0)))
time_now = time() * 1000
delay = str(time_now - self.last_time)
self.last_time = time_now
if self.snr_file != "":
f_snr = open(self.snr_file, 'a')
f_snr.write(str(snr) + '\n')
f_snr.close()
if self.enc_file != "":
f_enc = open(self.enc_file, 'a')
f_enc.write(str(encoding) + '\n')
f_enc.close()
if self.delay_file != "":
f_delay = open(self.delay_file, 'a')
f_delay.write(delay + '\n')
f_delay.close()
if self.debug:
print("SNR:" + str(snr))
print("Encoding:" + str(encoding))
print("Delay in millis: " + delay)
def __init__(self, tune_freq=1, sample_rate=1, fft_len=1, channel_space=1, search_bw=1, log=False, verbose=False):
gr.sync_block.__init__(self,
name="spectrum_logger",
in_sig=None,
out_sig=[np.float32])
self.sample_rate = sample_rate
self.channel_space = channel_space
self.search_bw = search_bw
self.tune_freq = tune_freq
self.log = log
self.verbose = verbose
self.constraints = []
self.statistic = {}
self.settings = {'date':time.strftime("%y%m%d"), 'time':time.strftime("%H%M%S"), 'tune_freq':tune_freq, 'sample_rate':sample_rate, 'fft_len':fft_len,'channel_space':channel_space, 'search_bw':search_bw}
if self.log:
self.log_file = open('/tmp/ss_log'+'-'+ time.strftime("%y%m%d") + '-' + time.strftime("%H%M%S"),'w')
self.log_file.write('Time,'+time.strftime("%H%M%S") + ',sample_rate,' + str(sample_rate) +
',channel_space,' + str(channel_space) + ',search_bw,' + str(search_bw) +
',tune_freq,' + str(tune_freq) + '\n')
self.log_file.write('settings ' + str(self.settings) + '\n')
self.log_file.write('statistics ' + str(self.statistic) + '\n')
print 'successfully created log file'
print self.log_file
else:
print 'printing results'
#message ports
#self.message_port_register_out(pmt.intern('PDU spect_msg'))
self.message_port_register_in(pmt.intern('PDU from_ss'))
self.set_msg_handler(pmt.intern('PDU from_ss'), self.ss_rx_callback)
def __init__(self, snr_file, enc_file, delay_file, debug):
gr.sync_block.__init__(self,
"sink",
None,
None)
self.snr_file = snr_file
self.enc_file = enc_file
self.delay_file = delay_file
self.debug = debug
# Time in millis
self.last_time = time() * 1000
# Check if files have been provided and reset them
if self.snr_file != "":
open(self.snr_file, 'w').close()
else:
print("No file for SNR information provided.")
if self.enc_file != "":
open(self.enc_file, 'w').close()
else:
print("No file for Encoding information provided.")
if self.delay_file != "":
open(self.delay_file, 'w').close()
else:
print("No file for Frame Delay information provided.")
self.message_port_register_in(pmt.intern("frame data"))
self.set_msg_handler(pmt.intern("frame data"), self.write_data)
def __init__(self,f,fs):
gr.sync_block.__init__(self,"pcap_range_source",[],[])
self.message_port_register_in(pmt.intern("pdus"));
self.message_port_register_out(pmt.intern("pdus"));
self.set_msg_handler(pmt.intern("pdus"), self.handler);
self.f = f
self.fs = fs
def start(self):
self.count = self.count_init
self.thread.start()
reg = pmt.cons(pmt.intern("timer_event"), self.message_subscribers(pmt.intern("timer_event")))
reg_msg = pmt.cons(pmt.intern("ES_REGISTER_HANDLER"), reg)
print "subscribers: %s" % (str(self.message_subscribers(pmt.intern("timer_event"))))
print "registration message: %s" % (str(reg_msg))
self.message_port_pub(pmt.intern("which_stream"), reg_msg)
def __init__(self, PanId, SrcAddM):
# Variables externas Parametros
self.SrcAddM = SrcAddM
self.PanId = PanId
gr.sync_block.__init__(self, name="tx_mac_802_15_4", in_sig=[], out_sig=[])
self.message_port_register_in(pmt.intern("in"))
self.message_port_register_out(pmt.intern("out"))
self.set_msg_handler(pmt.intern("in"), self.make_MPDU) # Funcion
def __init__(self):
gr.sync_block.__init__(self,
name="tx_app_xbee",
in_sig=[],
out_sig=[])
self.message_port_register_in(pmt.intern("in"))
self.message_port_register_out(pmt.intern("out"))
self.set_msg_handler(pmt.intern("in"), self.make_APDU) #Funcion make_APDU
def __init__(self):
gr.basic_block.__init__(self,
name="print_header",
in_sig=[],
out_sig=[])
self.message_port_register_in(pmt.intern('in'))
self.set_msg_handler(pmt.intern('in'), self.handle_msg)
def __init__(self):
gr.sync_block.__init__(self, "burst_deframer", [], [])
self.message_port_register_in(pmt.intern("pdus"))
self.message_port_register_out(pmt.intern("pdus"))
self.set_msg_handler(pmt.intern("pdus"), self.handler)
self.npkt = 0
self.npkt_ok = 0
self.npkt_hok = 0
def __init__(self):
gr.basic_block.__init__(self,
name="chat_receiver",
in_sig=[], # No streaming ports!
out_sig=[])
# Register the message port
self.message_port_register_in(pmt.intern('in'))
self.set_msg_handler(pmt.intern('in'), self.handle_msg)
def __init__(self):
gr.basic_block.__init__(self,
name="beacon_parser",
in_sig=None,
out_sig=None)
self.message_port_register_in(pmt.intern('in'))
self.set_msg_handler(pmt.intern('in'), self.handle_msg)
def __init__(self, blkname="pyqt_raster", label="", *args):
gr.sync_block.__init__(self,blkname,[],[])
Qwt.QwtPlot.__init__(self, *args)
self.enabled = True
# set up message port
self.message_port_register_in(pmt.intern("pdus"))
self.set_msg_handler(pmt.intern("pdus"), self.handler);
# QwtPlot set up
self.setMinimumWidth(100)
self.setMinimumHeight(100)
self._lock = threading.Lock();
# set up label if desired
if not label == "":
ttl = Qwt.QwtText(label)
ttl.setFont(Qt.QFont("Helvetica",10))
self.setTitle(ttl)
# wedge everything as close as possible
self.plotLayout().setMargin(0)
self.plotLayout().setCanvasMargin(0)
self.plotLayout().setSpacing(0)
# set up background etc
self.setCanvasBackground(Qt.Qt.black)
self.alignScales()
# set up image raster
dim = (100,100)
self.__data = PlotImage('Image', dim[0], dim[1])
self.__data.attach(self)
self.__data.setData( numpy.random.normal(0,1e-9,dim) )
self.replot()
# connect the plot callback signal
QtCore.QObject.connect(self,
QtCore.SIGNAL("updatePlot(int)"),
self.do_plot)
# set up zoomer
self.zoomer = Qwt.QwtPlotZoomer(Qwt.QwtPlot.xBottom,
Qwt.QwtPlot.yLeft,
Qwt.QwtPicker.DragSelection,
Qwt.QwtPicker.AlwaysOff,
self.canvas())
self.zoomer.setRubberBandPen(Qt.QPen(Qt.Qt.black))
# Set up menu actions
actions = [("Start/Stop", self.toggle_enabled),
]
self.actions = [];
for a in actions:
action = QtGui.QAction(a[0], self)
action.triggered.connect(a[1])
self.actions.append(action)
def __init__(self, data_to_concat=[0xff]):
gr.basic_block.__init__(self,
name="data-concatenator",
in_sig=[],
out_sig=[])
self.message_port_register_out(pmt.intern('out'))
self.message_port_register_in(pmt.intern('in'))
self.set_msg_handler(pmt.intern('in'), self.handle_msg)
self.data_to_concat = data_to_concat
def __init__(self, k=0):
gr.sync_block.__init__(self,
name = "cpdu_average_power",
in_sig = [],
out_sig = []);
self.k = k
self.message_port_register_in(pmt.intern("cpdus"));
self.message_port_register_out(pmt.intern("cpdus"));
self.set_msg_handler(pmt.intern("cpdus"), self.handler);
def __init__(self):
gr.sync_block.__init__(
self, name="blockchain_source",
in_sig=None, out_sig=None)
self.header = "SATOSHIWIRELESS";
self.message_port_register_in(pmt.intern("msg_string"));
self.message_port_register_out(pmt.intern("pdu"))
self.set_msg_handler(pmt.intern("msg_string"), self.handle_msg);
def __init__(self):
gr.basic_block.__init__(self,
name="swap_crc",
in_sig=[],
out_sig=[])
self.message_port_register_in(pmt.intern('in'))
self.set_msg_handler(pmt.intern('in'), self.handle_msg)
self.message_port_register_out(pmt.intern('out'))
def send_packet_msg(self):
print(f'Passing packet to nic interface')
message = pmt.cons(pmt.intern('pkt'), pmt.to_pmt(self.current_packet.tobytes()))
def set_pdu_length(self, pdu_length):
self.pdu_length = pdu_length
self.blocks_message_strobe_0_0.set_msg(
pmt.intern("".join("b" for i in range(self.pdu_length))))
def __init__(self):
gr.top_block.__init__(self, "Wifi Transceiver 2")
##################################################
# Variables
##################################################
self.tx_gain = tx_gain = 1000e-3
self.samp_rate = samp_rate = 5e6
self.rx_gain = rx_gain = 500e-3
self.pdu_length = pdu_length = 500
self.mac_dst = mac_dst = [0x13, 0x13, 0x13, 0x13, 0x13, 0x13]
self.mac_addr = mac_addr = [0x12, 0x12, 0x12, 0x12, 0x12, 0x12]
self.lo_offset = lo_offset = 0
self.interval = interval = 1e3
self.freq = freq = 2.52e9
self.encoding = encoding = 0
self.chan_est = chan_est = 0
##################################################
# Blocks
##################################################
self.wifi_phy_hier_0 = wifi_phy_hier(
bandwidth=samp_rate,
chan_est=chan_est,
encoding=encoding,
frequency=freq,
sensitivity=0.56,
)
self.uhd_usrp_source_0 = uhd.usrp_source(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_source_0.set_time_now(uhd.time_spec(time.time()),
uhd.ALL_MBOARDS)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(freq,
rf_freq=freq - lo_offset,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0)
self.uhd_usrp_source_0.set_normalized_gain(rx_gain, 0)
self.uhd_usrp_sink_0_0 = uhd.usrp_sink(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
"packet_len",
)
self.uhd_usrp_sink_0_0.set_time_now(uhd.time_spec(time.time()),
uhd.ALL_MBOARDS)
self.uhd_usrp_sink_0_0.set_samp_rate(samp_rate)
self.uhd_usrp_sink_0_0.set_center_freq(
uhd.tune_request(freq,
rf_freq=freq - lo_offset,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0)
self.uhd_usrp_sink_0_0.set_normalized_gain(tx_gain, 0)
self.toolkit_cs_0 = toolkit.cs()
self.macprotocols_frame_buffer_0 = macprotocols.frame_buffer(
256, False, 0, True)
self.macprotocols_csma_ca_0 = macprotocols.csma_ca((mac_addr), 9, 16,
34, 1000, -60, True)
self.logpwrfft_x_0 = logpwrfft.logpwrfft_c(
sample_rate=samp_rate,
fft_size=64,
ref_scale=2,
frame_rate=30,
avg_alpha=1.0,
average=False,
)
self.ieee802_11_parse_mac_0 = ieee802_11.parse_mac(False, False)
self.ieee802_11_mac_0_0 = ieee802_11.mac(
(mac_addr), (mac_dst), ([0xff, 0xff, 0xff, 0xff, 0xff, 255]))
(self.ieee802_11_mac_0_0).set_min_output_buffer(256)
(self.ieee802_11_mac_0_0).set_max_output_buffer(4096)
self.foo_wireshark_connector_0_0 = foo.wireshark_connector(127, False)
self.foo_wireshark_connector_0 = foo.wireshark_connector(127, False)
self.foo_packet_pad2_0 = foo.packet_pad2(False, False, 0.001, 10000,
10000)
(self.foo_packet_pad2_0).set_min_output_buffer(100000)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(
gr.sizeof_float * 1, 64)
self.blocks_socket_pdu_0 = blocks.socket_pdu("UDP_SERVER", "", "52000",
10000, False)
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc((0.6, ))
(self.blocks_multiply_const_vxx_0).set_min_output_buffer(100000)
self.blocks_message_strobe_0_0 = blocks.message_strobe(
pmt.intern("".join("b" for i in range(pdu_length))), interval)
self.blocks_file_sink_0_0 = blocks.file_sink(gr.sizeof_char * 1,
"/tmp/wifi_rx.pcap",
False)
self.blocks_file_sink_0_0.set_unbuffered(True)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_char * 1,
"/tmp/wifi_rx_all.pcap",
False)
self.blocks_file_sink_0.set_unbuffered(True)
##################################################
# Connections
##################################################
self.msg_connect((self.blocks_message_strobe_0_0, 'strobe'),
(self.ieee802_11_mac_0_0, 'app in'))
self.msg_connect((self.blocks_socket_pdu_0, 'pdus'),
(self.ieee802_11_mac_0_0, 'app in'))
self.msg_connect((self.ieee802_11_mac_0_0, 'app out'),
(self.foo_wireshark_connector_0_0, 'in'))
self.msg_connect((self.ieee802_11_mac_0_0, 'phy out'),
(self.macprotocols_frame_buffer_0, 'app in'))
self.msg_connect((self.macprotocols_csma_ca_0, 'frame to app'),
(self.ieee802_11_mac_0_0, 'phy in'))
self.msg_connect((self.macprotocols_csma_ca_0, 'frame request'),
(self.macprotocols_frame_buffer_0, 'req in 0'))
self.msg_connect((self.macprotocols_csma_ca_0, 'request to cs'),
(self.toolkit_cs_0, 'in_msg'))
self.msg_connect((self.macprotocols_csma_ca_0, 'frame to phy'),
(self.wifi_phy_hier_0, 'mac_in'))
self.msg_connect((self.macprotocols_frame_buffer_0, 'frame out 0'),
(self.macprotocols_csma_ca_0, 'frame from buffer'))
self.msg_connect((self.toolkit_cs_0, 'out_msg'),
(self.macprotocols_csma_ca_0, 'cs in'))
self.msg_connect((self.wifi_phy_hier_0, 'mac_out'),
(self.foo_wireshark_connector_0, 'in'))
self.msg_connect((self.wifi_phy_hier_0, 'mac_out'),
(self.ieee802_11_parse_mac_0, 'in'))
self.msg_connect((self.wifi_phy_hier_0, 'mac_out'),
(self.macprotocols_csma_ca_0, 'frame from phy'))
self.connect((self.blocks_multiply_const_vxx_0, 0),
(self.foo_packet_pad2_0, 0))
self.connect((self.blocks_vector_to_stream_0, 0),
(self.toolkit_cs_0, 0))
self.connect((self.foo_packet_pad2_0, 0), (self.uhd_usrp_sink_0_0, 0))
self.connect((self.foo_wireshark_connector_0, 0),
(self.blocks_file_sink_0, 0))
self.connect((self.foo_wireshark_connector_0_0, 0),
(self.blocks_file_sink_0_0, 0))
self.connect((self.logpwrfft_x_0, 0),
(self.blocks_vector_to_stream_0, 0))
self.connect((self.uhd_usrp_source_0, 0), (self.logpwrfft_x_0, 0))
self.connect((self.uhd_usrp_source_0, 0), (self.wifi_phy_hier_0, 0))
self.connect((self.wifi_phy_hier_0, 0),
(self.blocks_multiply_const_vxx_0, 0))
def test_98(self):
"""
Test case generated by test-case generator
"""
##################################################
# Variables
##################################################
# Input data into the system
src_data = "PKdhtXMmr18n2L9K88eMlGn7CcctT9RwKSB1FebW397VI5uG1yhc3uavuaOb9vyJ"
self.bw = bw = 250000
self.sf = sf = 11
self.samp_rate = samp_rate = 250000
self.pay_len = pay_len = 64
self.n_frame = n_frame = 2
self.impl_head = impl_head = False
self.has_crc = has_crc = True
self.frame_period = frame_period = 200
self.cr = cr = 6
##################################################
# Blocks
##################################################
# Tx side
self.lora_sdr_whitening_0 = lora_sdr.whitening()
self.lora_sdr_modulate_0 = lora_sdr.modulate(sf, samp_rate, bw)
self.lora_sdr_modulate_0.set_min_output_buffer(10000000)
self.lora_sdr_interleaver_0 = lora_sdr.interleaver(cr, sf)
self.lora_sdr_header_0 = lora_sdr.header(impl_head, has_crc, cr)
self.lora_sdr_hamming_enc_0 = lora_sdr.hamming_enc(cr, sf)
self.lora_sdr_gray_decode_0 = lora_sdr.gray_decode(sf)
self.lora_sdr_data_source_0_1_0 = lora_sdr.data_source(
pay_len, n_frame, src_data)
self.lora_sdr_add_crc_0 = lora_sdr.add_crc(has_crc)
self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_gr_complex * 1)
self.blocks_message_strobe_random_0_1_0 = blocks.message_strobe_random(
pmt.intern(''), blocks.STROBE_UNIFORM, frame_period, 5)
# Rx side
self.rational_resampler_xxx_0 = filter.rational_resampler_ccc(
interpolation=4, decimation=1, taps=None, fractional_bw=None)
self.lora_sdr_header_decoder_0 = lora_sdr.header_decoder(
impl_head, cr, pay_len, has_crc)
self.lora_sdr_hamming_dec_0 = lora_sdr.hamming_dec()
self.lora_sdr_gray_enc_0 = lora_sdr.gray_enc()
self.lora_sdr_frame_sync_0 = lora_sdr.frame_sync(
samp_rate, bw, sf, impl_head)
self.lora_sdr_fft_demod_0 = lora_sdr.fft_demod(samp_rate, bw, sf,
impl_head)
self.lora_sdr_dewhitening_0 = lora_sdr.dewhitening()
self.lora_sdr_deinterleaver_0 = lora_sdr.deinterleaver(sf)
self.lora_sdr_crc_verif_0 = lora_sdr.crc_verif()
self.blocks_message_debug_0 = blocks.message_debug()
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex * 1,
samp_rate, True)
##################################################
# Connections
##################################################
# Tx side
self.tb.msg_connect(
(self.blocks_message_strobe_random_0_1_0, 'strobe'),
(self.lora_sdr_data_source_0_1_0, 'trigg'))
self.tb.msg_connect((self.lora_sdr_data_source_0_1_0, 'msg'),
(self.lora_sdr_add_crc_0, 'msg'))
self.tb.msg_connect((self.lora_sdr_data_source_0_1_0, 'msg'),
(self.lora_sdr_header_0, 'msg'))
self.tb.msg_connect((self.lora_sdr_data_source_0_1_0, 'msg'),
(self.lora_sdr_interleaver_0, 'msg'))
self.tb.msg_connect((self.lora_sdr_data_source_0_1_0, 'msg'),
(self.lora_sdr_modulate_0, 'msg'))
self.tb.msg_connect((self.lora_sdr_data_source_0_1_0, 'msg'),
(self.lora_sdr_whitening_0, 'msg'))
self.tb.connect((self.lora_sdr_add_crc_0, 0),
(self.lora_sdr_hamming_enc_0, 0))
self.tb.connect((self.lora_sdr_gray_decode_0, 0),
(self.lora_sdr_modulate_0, 0))
self.tb.connect((self.lora_sdr_hamming_enc_0, 0),
(self.lora_sdr_interleaver_0, 0))
self.tb.connect((self.lora_sdr_header_0, 0),
(self.lora_sdr_add_crc_0, 0))
self.tb.connect((self.lora_sdr_interleaver_0, 0),
(self.lora_sdr_gray_decode_0, 0))
self.tb.connect((self.lora_sdr_whitening_0, 0),
(self.lora_sdr_header_0, 0))
self.tb.connect((self.lora_sdr_modulate_0, 0),
(self.blocks_throttle_0, 0))
# Rx side
self.tb.connect((self.blocks_throttle_0, 0),
(self.rational_resampler_xxx_0, 0))
self.tb.msg_connect((self.lora_sdr_crc_verif_0, 'msg'),
(self.blocks_message_debug_0, 'store'))
self.tb.msg_connect((self.lora_sdr_frame_sync_0, 'new_frame'),
(self.lora_sdr_deinterleaver_0, 'new_frame'))
self.tb.msg_connect((self.lora_sdr_frame_sync_0, 'new_frame'),
(self.lora_sdr_dewhitening_0, 'new_frame'))
self.tb.msg_connect((self.lora_sdr_frame_sync_0, 'new_frame'),
(self.lora_sdr_fft_demod_0, 'new_frame'))
self.tb.msg_connect((self.lora_sdr_frame_sync_0, 'new_frame'),
(self.lora_sdr_hamming_dec_0, 'new_frame'))
self.tb.msg_connect((self.lora_sdr_frame_sync_0, 'new_frame'),
(self.lora_sdr_header_decoder_0, 'new_frame'))
self.tb.msg_connect((self.lora_sdr_header_decoder_0, 'pay_len'),
(self.lora_sdr_crc_verif_0, 'pay_len'))
self.tb.msg_connect((self.lora_sdr_header_decoder_0, 'CRC'),
(self.lora_sdr_crc_verif_0, 'CRC'))
self.tb.msg_connect((self.lora_sdr_header_decoder_0, 'CR'),
(self.lora_sdr_deinterleaver_0, 'CR'))
self.tb.msg_connect((self.lora_sdr_header_decoder_0, 'pay_len'),
(self.lora_sdr_dewhitening_0, 'pay_len'))
self.tb.msg_connect((self.lora_sdr_header_decoder_0, 'CRC'),
(self.lora_sdr_dewhitening_0, 'CRC'))
self.tb.msg_connect((self.lora_sdr_header_decoder_0, 'CR'),
(self.lora_sdr_fft_demod_0, 'CR'))
self.tb.msg_connect((self.lora_sdr_header_decoder_0, 'CR'),
(self.lora_sdr_frame_sync_0, 'CR'))
self.tb.msg_connect((self.lora_sdr_header_decoder_0, 'err'),
(self.lora_sdr_frame_sync_0, 'err'))
self.tb.msg_connect((self.lora_sdr_header_decoder_0, 'CRC'),
(self.lora_sdr_frame_sync_0, 'crc'))
self.tb.msg_connect((self.lora_sdr_header_decoder_0, 'pay_len'),
(self.lora_sdr_frame_sync_0, 'pay_len'))
self.tb.msg_connect((self.lora_sdr_header_decoder_0, 'CR'),
(self.lora_sdr_hamming_dec_0, 'CR'))
self.tb.connect((self.lora_sdr_deinterleaver_0, 0),
(self.lora_sdr_hamming_dec_0, 0))
self.tb.connect((self.lora_sdr_dewhitening_0, 0),
(self.lora_sdr_crc_verif_0, 0))
self.tb.connect((self.lora_sdr_fft_demod_0, 0),
(self.lora_sdr_gray_enc_0, 0))
self.tb.connect((self.lora_sdr_frame_sync_0, 0),
(self.lora_sdr_fft_demod_0, 0))
self.tb.connect((self.lora_sdr_gray_enc_0, 0),
(self.lora_sdr_deinterleaver_0, 0))
self.tb.connect((self.lora_sdr_hamming_dec_0, 0),
(self.lora_sdr_header_decoder_0, 0))
self.tb.connect((self.lora_sdr_header_decoder_0, 0),
(self.lora_sdr_dewhitening_0, 0))
self.tb.connect((self.rational_resampler_xxx_0, 0),
(self.lora_sdr_frame_sync_0, 0))
# run the flowgraph, since we use a message strobe we have to run and stop the flowgraph with some computation time inbetween
self.tb.start()
time.sleep(10)
self.tb.stop()
self.tb.wait()
# try to get get the message from the store port of the message debug printer and convert to string from pmt message
try:
msg = pmt.symbol_to_string(
self.blocks_message_debug_0.get_message(0))
except:
# if not possible set message to be None
msg = None
# check if message received is the same as the message decoded
self.assertMultiLineEqual(
src_data,
msg,
msg="Error decoded data {0} is not the same as input data {1}".
format(msg, src_data))
def test_001_headerpadding_payload_offset (self):
""" Like test 1, but with header padding + payload offset. """
n_zeros = 3
header = (1, 2, 3)
header_padding = 1
payload_offset = -1
payload = tuple(range(5, 20))
data_signal = (0,) * n_zeros + header + payload + (0,) * 100
trigger_signal = [0,] * len(data_signal)
trigger_signal[n_zeros] = 1
# This goes on output 1, item 3 + 1 (for payload offset)
testtag4 = make_tag('tag4', 314, n_zeros + len(header) + 3)
data_src = blocks.vector_source_f(
data_signal,
False,
tags=(testtag4,)
)
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
len(header),
1, # Items per symbol
0, # Guard interval
"frame_len", # TSB tag key
"detect", # Trigger tag key
False, # No symbols please
gr.sizeof_float, # Item size
"", # Timing tag key
1.0, # Samp rate
(), # No special tags
header_padding
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you
header_sink = blocks.vector_sink_f()
payload_sink = blocks.vector_sink_f()
self.tb.connect(data_src, (hpd, 0))
self.tb.connect(trigger_src, (hpd, 1))
self.tb.connect((hpd, 0), header_sink)
self.tb.connect((hpd, 1), payload_sink)
self.tb.start()
time.sleep(.2) # Need this, otherwise, the next message is ignored
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.to_pmt({'frame_len': len(payload), 'payload_offset': payload_offset})
)
while len(payload_sink.data()) < len(payload):
time.sleep(.2)
self.tb.stop()
self.tb.wait()
# Header is now padded:
self.assertEqual(header_sink.data(), (0,) + header + (payload[0],))
# Payload is now offset:
self.assertEqual(
payload_sink.data(),
data_signal[n_zeros + len(header) + payload_offset:n_zeros + len(header) + payload_offset + len(payload)]
)
ptags_payload = {}
for tag in payload_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_payload[ptag.key] = ptag.offset
expected_tags_payload = {
'frame_len': 0,
'payload_offset': 0,
'tag4': 3 - payload_offset,
}
self.assertEqual(expected_tags_payload, ptags_payload)
def __init__(self, username, mode):
gr.basic_block.__init__(self,
name="ATA Control",
in_sig=None,
out_sig=None)
self.hat_creek = EarthLocation(lat='40d49.05m',
lon='-121d28.40m',
height=986.0 * u.meter)
self.pos = ap.ATAPositions()
self.mode = mode
self.obs_info = {}
self.ant_list = []
self.my_ants = []
self.is_configured = False
#run the flowgraph either online or offline
if mode == 'online':
try_ping = subprocess.Popen(['ping', '-c', '1', 'control'],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
stdout, stderr = try_ping.communicate()
ping_output = stdout.decode('utf-8')
ping_success = "1 packets transmitted, 1 received"
if ping_success in ping_output:
try:
alarm = ac.get_alarm()
if alarm['user'] == username:
self.is_user = True
print(
"You are the primary user. You have full permissions."
)
else:
self.is_user = False
raise Exception(
"Another user, {0}, has the array locked out. \n"
"You do not have permission to observe.".format(
alarm['user']))
except KeyError:
self.is_user = False
raise Exception(
"The array is not locked out under your username.\n"
"You do not have permission to observe.")
self.message_port_register_in(pmt.intern("command"))
self.set_msg_handler(pmt.intern("command"), self.handle_msg)
else:
exception_msg = "Sorry, you must be able to connect to the ATA\n"\
"machine. if you want to observe. If you want to test\n"\
"the code on your local computer without observing, \n"\
"switch to Offline Mode."
raise Exception(exception_msg)
elif mode == 'offline':
self.message_port_register_in(pmt.intern("command"))
self.set_msg_handler(pmt.intern("command"),
self.handle_msg_offline)
else:
print(
"Error: No Control Block Mode specified! Select mode and try again."
)
def test_003_t (self):
"""
Like test 1, but twice, plus one fail
"""
### Tx Data
n_zeros = 5
header = (1, 2, 3)
header_fail = (-1, -2, -4) # Contents don't really matter
payload1 = tuple(range(5, 20))
payload2 = (42,)
sampling_rate = 2
data_signal = (0,) * n_zeros + header + payload1
trigger_signal = [0,] * len(data_signal) * 2
trigger_signal[n_zeros] = 1
trigger_signal[len(data_signal)] = 1
trigger_signal[len(data_signal)+len(header_fail)+n_zeros] = 1
print("Triggers at: {0} {1} {2}".format(
n_zeros,
len(data_signal),
len(data_signal)+len(header_fail)+n_zeros)
)
tx_signal = data_signal + \
header_fail + (0,) * n_zeros + \
header + payload2 + (0,) * 1000
# Timing tag: This is preserved and updated:
timing_tag = make_tag('rx_time', (0, 0), 0)
# Rx freq tags:
rx_freq_tag1 = make_tag('rx_freq', 1.0, 0)
rx_freq_tag2 = make_tag('rx_freq', 1.5, 29)
rx_freq_tag3 = make_tag('rx_freq', 2.0, 30)
### Flow graph
data_src = blocks.vector_source_f(
tx_signal, False,
tags=(timing_tag, rx_freq_tag1, rx_freq_tag2, rx_freq_tag3)
)
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
header_len=len(header),
items_per_symbol=1,
guard_interval=0,
length_tag_key="frame_len",
trigger_tag_key="detect",
output_symbols=False,
itemsize=gr.sizeof_float,
timing_tag_key='rx_time',
samp_rate=sampling_rate,
special_tags=('rx_freq',),
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you
header_sink = blocks.vector_sink_f()
payload_sink = blocks.vector_sink_f()
self.tb.connect(data_src, (hpd, 0))
self.tb.connect(trigger_src, (hpd, 1))
self.tb.connect((hpd, 0), header_sink)
self.tb.connect((hpd, 1), payload_sink)
self.tb.start()
time.sleep(.2) # Need this, otherwise, the next message is ignored
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.from_long(len(payload1))
)
while len(payload_sink.data()) < len(payload1):
time.sleep(.2)
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.PMT_F
)
# This next command is a bit of a showstopper, but there's no condition to check upon
# to see if the previous msg handling is finished
time.sleep(.7)
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.from_long(len(payload2))
)
while len(payload_sink.data()) < len(payload1) + len(payload2):
time.sleep(.2)
self.tb.stop()
self.tb.wait()
# Signal description:
# 0: 5 zeros
# 5: header 1
# 8: payload 1 (length: 15)
# 23: header 2 (fail)
# 26: 5 zeros
# 31: header 3
# 34: payload 2 (length 1)
# 35: 1000 zeros
self.assertEqual(header_sink.data(), header + header_fail + header)
self.assertEqual(payload_sink.data(), payload1 + payload2)
tags_payload = [gr.tag_to_python(x) for x in payload_sink.tags()]
tags_payload = sorted([(x.offset, x.key, x.value) for x in tags_payload])
tags_expected_payload = [
(0, 'frame_len', len(payload1)),
(len(payload1), 'frame_len', len(payload2)),
]
tags_header = [gr.tag_to_python(x) for x in header_sink.tags()]
tags_header = sorted([(x.offset, x.key, x.value) for x in tags_header])
tags_expected_header = [
(0, 'rx_freq', 1.0),
(0, 'rx_time', (2, 0.5)), # Hard coded time value :( Is n_zeros/sampling_rate
(len(header), 'rx_freq', 1.0),
(len(header), 'rx_time', (11, .5)), # Hard coded time value :(. See above.
(2*len(header), 'rx_freq', 2.0),
(2*len(header), 'rx_time', (15, .5)), # Hard coded time value :(. See above.
]
self.assertEqual(tags_header, tags_expected_header)
self.assertEqual(tags_payload, tags_expected_payload)
def __init__(self, blkname="text_input", label="", *args):
gr.sync_block.__init__(self, blkname, [], [])
QtGui.QLineEdit.__init__(self, *args)
self.returnPressed.connect(self.text_changed)
self.message_port_register_out(pmt.intern("pdus"))
def __init__(self, fn):
gr.sync_block.__init__(self, "pdu_lambda", [], [])
self.set_fn(fn)
self.message_port_register_in(pmt.intern("pdus"))
self.message_port_register_out(pmt.intern("pdus"))
self.set_msg_handler(pmt.intern("pdus"), self.handler)
def __init__(self,
pre_bits=[
0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1,
1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0,
0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0,
1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0,
0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0
]):
gr.top_block.__init__(self, "Psk Burst Tx")
Qt.QWidget.__init__(self)
self.setWindowTitle("Psk Burst Tx")
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "psk_burst_tx")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Parameters
##################################################
self.pre_bits = pre_bits
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 100e3
self.ldpc_enc = ldpc_enc = fec.ldpc_encoder_make(
'/home/abraxas3d/goodies/share/gnuradio/fec/ldpc/271.127.3.112')
##################################################
# Blocks
##################################################
self.root_raised_cosine_filter_0 = filter.interp_fir_filter_ccf(
2, firdes.root_raised_cosine(1, 2.0, 1, 0.35, 41))
self.qtgui_time_sink_x_0 = qtgui.time_sink_c(
8192, #size
samp_rate, #samp_rate
"", #name
1 #number of inputs
)
self.qtgui_time_sink_x_0.set_update_time(0.10)
self.qtgui_time_sink_x_0.set_y_axis(-1, 1)
self.qtgui_time_sink_x_0.set_y_label('Amplitude', "")
self.qtgui_time_sink_x_0.enable_tags(-1, True)
self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE,
qtgui.TRIG_SLOPE_POS, 0.0, 0,
0, "")
self.qtgui_time_sink_x_0.enable_autoscale(True)
self.qtgui_time_sink_x_0.enable_grid(False)
self.qtgui_time_sink_x_0.enable_axis_labels(True)
self.qtgui_time_sink_x_0.enable_control_panel(False)
if not True:
self.qtgui_time_sink_x_0.disable_legend()
labels = ['', '', '', '', '', '', '', '', '', '']
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"blue", "red", "green", "black", "cyan", "magenta", "yellow",
"dark red", "dark green", "blue"
]
styles = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(2 * 1):
if len(labels[i]) == 0:
if (i % 2 == 0):
self.qtgui_time_sink_x_0.set_line_label(
i, "Re{{Data {0}}}".format(i / 2))
else:
self.qtgui_time_sink_x_0.set_line_label(
i, "Im{{Data {0}}}".format(i / 2))
else:
self.qtgui_time_sink_x_0.set_line_label(i, labels[i])
self.qtgui_time_sink_x_0.set_line_width(i, widths[i])
self.qtgui_time_sink_x_0.set_line_color(i, colors[i])
self.qtgui_time_sink_x_0.set_line_style(i, styles[i])
self.qtgui_time_sink_x_0.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_0_win = sip.wrapinstance(
self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_time_sink_x_0_win, 0, 0, 1,
0)
self.qtgui_const_sink_x_0 = qtgui.const_sink_c(
8192, #size
"", #name
1 #number of inputs
)
self.qtgui_const_sink_x_0.set_update_time(0.10)
self.qtgui_const_sink_x_0.set_y_axis(-2, 2)
self.qtgui_const_sink_x_0.set_x_axis(-2, 2)
self.qtgui_const_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE,
qtgui.TRIG_SLOPE_POS, 0.0,
0, "")
self.qtgui_const_sink_x_0.enable_autoscale(False)
self.qtgui_const_sink_x_0.enable_grid(False)
self.qtgui_const_sink_x_0.enable_axis_labels(True)
if not True:
self.qtgui_const_sink_x_0.disable_legend()
labels = ['', '', '', '', '', '', '', '', '', '']
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"blue", "red", "red", "red", "red", "red", "red", "red", "red",
"red"
]
styles = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
markers = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_const_sink_x_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_const_sink_x_0.set_line_label(i, labels[i])
self.qtgui_const_sink_x_0.set_line_width(i, widths[i])
self.qtgui_const_sink_x_0.set_line_color(i, colors[i])
self.qtgui_const_sink_x_0.set_line_style(i, styles[i])
self.qtgui_const_sink_x_0.set_line_marker(i, markers[i])
self.qtgui_const_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_const_sink_x_0_win = sip.wrapinstance(
self.qtgui_const_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_const_sink_x_0_win, 1, 1)
self.pyqt_meta_text_output_0 = pyqt.meta_text_output()
self._pyqt_meta_text_output_0_win = self.pyqt_meta_text_output_0
self.top_layout.addWidget(self._pyqt_meta_text_output_0_win)
self.pyqt_ctime_plot_0 = pyqt.ctime_plot('')
self._pyqt_ctime_plot_0_win = self.pyqt_ctime_plot_0
self.top_grid_layout.addWidget(self._pyqt_ctime_plot_0_win, 1, 0)
self.mapper_mapper_msg_0 = mapper.mapper_msg(mapper.QPSK,
([0, 1, 3, 2]))
self.fec_async_encoder_0 = fec.async_encoder(ldpc_enc, False, True,
True, 1500)
self.es_source_0 = es.source(1 * [gr.sizeof_gr_complex], 1, 2)
self.channels_channel_model_0_0 = channels.channel_model(
noise_voltage=0.05,
frequency_offset=random.random() * 1e-4,
epsilon=1.0 + random.random() * 1e-4,
taps=(1.0 + 1.0j, ),
noise_seed=0,
block_tags=False)
self.burst_scheduler_0 = burst.burst_scheduler()
self.burst_randomizer_0 = burst.randomizer(
([0, 14, 15]), ([1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0]),
100000)
self.burst_preamble_insert_0 = burst.preamble_insert((pre_bits))
self.burst_padder_0 = burst.padder(144)
self.burst_framer_0 = burst.framer(144)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex * 1,
samp_rate, True)
self.blocks_random_pdu_0 = blocks.random_pdu(50, 256 / 2, chr(0xFF), 2)
self.blocks_message_strobe_0 = blocks.message_strobe(
pmt.intern("TEST"), 1000)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_gr_complex * 1,
'/tmp/psk_ldpc_xmit.dat',
False)
self.blocks_file_sink_0.set_unbuffered(False)
##################################################
# Connections
##################################################
self.msg_connect((self.blocks_message_strobe_0, 'strobe'),
(self.blocks_random_pdu_0, 'generate'))
self.msg_connect((self.blocks_random_pdu_0, 'pdus'),
(self.burst_framer_0, 'packed_pdus'))
self.msg_connect((self.burst_framer_0, 'unpacked_pdus'),
(self.burst_padder_0, 'pdus'))
self.msg_connect((self.burst_padder_0, 'pdus'),
(self.burst_randomizer_0, 'pdus'))
self.msg_connect((self.burst_preamble_insert_0, 'pdus'),
(self.mapper_mapper_msg_0, 'pdus'))
self.msg_connect((self.burst_randomizer_0, 'pdus'),
(self.fec_async_encoder_0, 'in'))
self.msg_connect((self.burst_scheduler_0, 'sched_pdu'),
(self.es_source_0, 'schedule_event'))
self.msg_connect((self.burst_scheduler_0, 'sched_pdu'),
(self.pyqt_meta_text_output_0, 'pdus'))
self.msg_connect((self.es_source_0, 'nproduced'),
(self.burst_scheduler_0, 'nproduced'))
self.msg_connect((self.fec_async_encoder_0, 'out'),
(self.burst_preamble_insert_0, 'pdus'))
self.msg_connect((self.mapper_mapper_msg_0, 'cpdus'),
(self.burst_scheduler_0, 'sched_pdu'))
self.msg_connect((self.mapper_mapper_msg_0, 'cpdus'),
(self.pyqt_ctime_plot_0, 'cpdus'))
self.connect((self.blocks_throttle_0, 0),
(self.root_raised_cosine_filter_0, 0))
self.connect((self.channels_channel_model_0_0, 0),
(self.blocks_file_sink_0, 0))
self.connect((self.channels_channel_model_0_0, 0),
(self.qtgui_const_sink_x_0, 0))
self.connect((self.channels_channel_model_0_0, 0),
(self.qtgui_time_sink_x_0, 0))
self.connect((self.es_source_0, 0), (self.blocks_throttle_0, 0))
self.connect((self.root_raised_cosine_filter_0, 0),
(self.channels_channel_model_0_0, 0))
def test_002_callbacks(self):
in_data = [0, 0, 0, 0]
in_meta = pmt.make_dict()
expected_meta1 = pmt.dict_add(in_meta, pmt.intern('num'),
pmt.from_long(4))
expected_meta2 = pmt.dict_add(
pmt.dict_add(in_meta, pmt.intern('num'), pmt.from_long(4)),
pmt.intern('name'), pmt.intern('param1'))
expected_meta3 = pmt.dict_add(
pmt.dict_add(in_meta, pmt.intern('name'), pmt.intern('param1')),
pmt.intern('num'), pmt.from_long(1))
in_pdu = pmt.cons(in_meta, pmt.init_u8vector(len(in_data), in_data))
expected_pdu1 = pmt.cons(expected_meta1,
pmt.init_u8vector(len(in_data), in_data))
expected_pdu2 = pmt.cons(expected_meta2,
pmt.init_u8vector(len(in_data), in_data))
expected_pdu3 = pmt.cons(expected_meta3,
pmt.init_u8vector(len(in_data), in_data))
self.tb.start()
time.sleep(.001)
self.emitter.emit(pmt.intern("MALFORMED PDU"))
time.sleep(.001)
self.emitter.emit(in_pdu)
time.sleep(.001)
self.set.set_key(pmt.intern('name'))
self.set.set_val(pmt.intern('param1'))
time.sleep(.001)
self.emitter.emit(self.debug.get_message(0))
time.sleep(.001)
self.set.set_kv(pmt.intern('num'), pmt.from_long(1))
time.sleep(.001)
self.emitter.emit(self.debug.get_message(1))
time.sleep(.01)
self.tb.stop()
self.tb.wait()
self.assertTrue(pmt.equal(self.debug.get_message(0), expected_pdu1))
self.assertTrue(pmt.equal(self.debug.get_message(1), expected_pdu2))
self.assertTrue(pmt.equal(self.debug.get_message(2), expected_pdu3))
def __init__(self):
gr.top_block.__init__(self, "Tag Test")
Qt.QWidget.__init__(self)
self.setWindowTitle("Tag Test")
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "tag_test")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
self.qtgui_time_sink_x_0 = qtgui.time_sink_c(
1024, #size
samp_rate, #samp_rate
"", #name
1 #number of inputs
)
self.qtgui_time_sink_x_0.set_update_time(0.10)
self.qtgui_time_sink_x_0.set_y_axis(-1, 1)
self.qtgui_time_sink_x_0.set_y_label("Amplitude", "")
self.qtgui_time_sink_x_0.enable_tags(-1, True)
self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, 0, "")
self.qtgui_time_sink_x_0.enable_autoscale(False)
self.qtgui_time_sink_x_0.enable_grid(False)
self.qtgui_time_sink_x_0.enable_control_panel(False)
if not True:
self.qtgui_time_sink_x_0.disable_legend()
labels = ["", "", "", "", "",
"", "", "", "", ""]
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "blue"]
styles = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1,
-1, -1, -1, -1, -1]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(2*1):
if len(labels[i]) == 0:
if(i % 2 == 0):
self.qtgui_time_sink_x_0.set_line_label(i, "Re{{Data {0}}}".format(i/2))
else:
self.qtgui_time_sink_x_0.set_line_label(i, "Im{{Data {0}}}".format(i/2))
else:
self.qtgui_time_sink_x_0.set_line_label(i, labels[i])
self.qtgui_time_sink_x_0.set_line_width(i, widths[i])
self.qtgui_time_sink_x_0.set_line_color(i, colors[i])
self.qtgui_time_sink_x_0.set_line_style(i, styles[i])
self.qtgui_time_sink_x_0.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_0_win = sip.wrapinstance(self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_layout.addWidget(self._qtgui_time_sink_x_0_win)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, samp_rate,True)
self.blocks_tags_strobe_0 = blocks.tags_strobe(gr.sizeof_gr_complex*1, pmt.intern("TEST"), 1000, pmt.intern("strobe"))
self.blocks_add_xx_0 = blocks.add_vcc(1)
self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, 1000, 1, 0)
##################################################
# Connections
##################################################
self.connect((self.analog_sig_source_x_0, 0), (self.blocks_add_xx_0, 0))
self.connect((self.blocks_add_xx_0, 0), (self.blocks_throttle_0, 0))
self.connect((self.blocks_tags_strobe_0, 0), (self.blocks_add_xx_0, 1))
self.connect((self.blocks_throttle_0, 0), (self.qtgui_time_sink_x_0, 0))
def handler(self, pdu):
meta = pmt.car(pdu)
vec = pmt.to_python(pmt.cdr(pdu))
vec = self.fn(vec)
self.message_port_pub(pmt.intern("pdus"),
pmt.cons(meta, pmt.to_pmt(vec)))
def test_002_symbols (self):
"""
Same as before, but operate on symbols
"""
n_zeros = 1
items_per_symbol = 3
gi = 1
n_symbols = 4
header = (1, 2, 3)
payload = (1, 2, 3)
data_signal = (0,) * n_zeros + (0,) + header + ((0,) + payload) * n_symbols
trigger_signal = [0,] * len(data_signal)
trigger_signal[n_zeros] = 1
# This is dropped:
testtag1 = make_tag('tag1', 0, 0)
# This goes on output 0, item 0 (from the GI)
testtag2 = make_tag('tag2', 23, n_zeros)
# This goes on output 0, item 0 (middle of the header symbol)
testtag3 = make_tag('tag3', 42, n_zeros + gi + 1)
# This goes on output 1, item 1 (middle of the first payload symbol)
testtag4 = make_tag('tag4', 314, n_zeros + (gi + items_per_symbol) * 2 + 1)
data_src = blocks.vector_source_f(data_signal, False, tags=(testtag1, testtag2, testtag3, testtag4))
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
len(header) / items_per_symbol, # Header length (in symbols)
items_per_symbol, # Items per symbols
gi, # Items per guard time
"frame_len", # Frame length tag key
"detect", # Trigger tag key
True, # Output symbols (not items)
gr.sizeof_float # Bytes per item
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you
header_sink = blocks.vector_sink_f(items_per_symbol)
payload_sink = blocks.vector_sink_f(items_per_symbol)
self.tb.connect(data_src, (hpd, 0))
self.tb.connect(trigger_src, (hpd, 1))
self.tb.connect((hpd, 0), header_sink)
self.tb.connect((hpd, 1), payload_sink)
self.tb.start()
time.sleep(.2) # Need this, otherwise, the next message is ignored
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.from_long(n_symbols)
)
while len(payload_sink.data()) < len(payload) * n_symbols:
time.sleep(.2)
self.tb.stop()
self.tb.wait()
self.assertEqual(header_sink.data(), header)
self.assertEqual(payload_sink.data(), payload * n_symbols)
ptags_header = []
for tag in header_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_header.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_header = [
{'key': 'tag2', 'offset': 0},
{'key': 'tag3', 'offset': 0},
]
self.assertEqual(expected_tags_header, ptags_header)
ptags_payload = []
for tag in payload_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_payload.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_payload = [
{'key': 'frame_len', 'offset': 0},
{'key': 'tag4', 'offset': 1},
]
self.assertEqual(expected_tags_payload, ptags_payload)
def __init__(self,
constellation=gnuradio.digital.constellation_qpsk().base()):
gr.top_block.__init__(self, "Test_slide_window")
Qt.QWidget.__init__(self)
self.setWindowTitle("Test_slide_window")
qtgui.util.check_set_qss()
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "Test_slide_window")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Parameters
##################################################
self.constellation = constellation
##################################################
# Variables
##################################################
self.sps = sps = 4
self.range_rx_gain = range_rx_gain = 0
self.range_mu = range_mu = 0.6
self.usrp_device_address = usrp_device_address = "addr=10.0.0.6"
self.tx_center_frequency = tx_center_frequency = 3.8e8
self.system_time_granularity_us = system_time_granularity_us = 1000
self.source_address = source_address = 1
self.samp_rate = samp_rate = 1000000
self.rx_gain = rx_gain = range_rx_gain
self.rx_center_frequency = rx_center_frequency = 3.9e8
self.rrc = rrc = firdes.root_raised_cosine(1.0, sps, 1, 0.5, 11 * sps)
self.mu = mu = range_mu
self.diff_preamble_128 = diff_preamble_128 = [
1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0,
1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1,
1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0,
1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0,
1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,
1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0,
1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1,
0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0,
0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0,
0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1,
0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1,
1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0
][0:128]
self.destination_address = destination_address = 2
self.cs_threshold = cs_threshold = 0.005
##################################################
# Blocks
##################################################
self._range_rx_gain_range = Range(0, 1, 1, 0, 200)
self._range_rx_gain_win = RangeWidget(self._range_rx_gain_range,
self.set_range_rx_gain,
'Rx Gain', "counter_slider",
float)
self.top_grid_layout.addWidget(self._range_rx_gain_win, 1, 0, 1, 1)
self._range_mu_range = Range(0, 1, 0.01, 0.6, 200)
self._range_mu_win = RangeWidget(self._range_mu_range,
self.set_range_mu,
'BB Derotation Gain',
"counter_slider", float)
self.top_grid_layout.addWidget(self._range_mu_win, 2, 0, 1, 1)
self.inets_timeout_0 = inets.timeout(0, 10, 1000, 1000, 1)
self.inets_slide_window_0 = inets.slide_window(
1, 22, 5, 1,
constellation.bits_per_symbol() * (samp_rate / sps), 200, 1)
self.inets_sending_0 = inets.sending(
develop_mode=0,
block_id=11,
constellation=gnuradio.digital.constellation_qpsk().base(),
preamble=diff_preamble_128,
samp_rate=samp_rate,
sps=sps,
system_time_granularity_us=system_time_granularity_us,
usrp_device_address=usrp_device_address,
center_frequency=tx_center_frequency)
self.inets_receiving_0 = inets.receiving(
1, 21,
gnuradio.digital.constellation_qpsk().base(), rrc, mu,
diff_preamble_128, rx_gain, samp_rate, sps, 30,
usrp_device_address, rx_center_frequency)
self.inets_framing_1 = inets.framing(0, 17, 2, 1, 0, 1,
destination_address, 1,
source_address, 1, 318, 2, 524, 2,
2, 1, 1, 0)
self.inets_framing_0 = inets.framing(0, 17, 1, 1, 0, 1,
destination_address, 1,
source_address, 1, 318, 2, 524, 2,
2, 1, 1, 0)
self.inets_frame_type_check_0 = inets.frame_type_check(
0, 25, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1)
self.inets_frame_probe_0 = inets.frame_probe(1, 100, 0)
self.inets_frame_index_check_0 = inets.frame_index_check(
1, 28, 1, 1, 1, 1, 1)
self.inets_frame_filter_1 = inets.frame_filter(0, 26, 0, 0, 0, 0, 8, 0,
0, 1)
self.inets_frame_buffer_0 = inets.frame_buffer(0, 16, 10, 1, 1)
self.inets_frame_analysis_0 = inets.frame_analysis(
0, 7, 1, 1, 1, 1, 1, 2, 2, 2, 1, source_address)
self.inets_dummy_source_0 = inets.dummy_source(0, 23, 100, 2, 20)
self.inets_address_check_0 = inets.address_check(0, 17, source_address)
self.blocks_socket_pdu_0 = blocks.socket_pdu("UDP_SERVER", 'localhost',
'52001', 10000, False)
self.blocks_message_strobe_0 = blocks.message_strobe(
pmt.intern("TEST"), 1000)
##################################################
# Connections
##################################################
self.msg_connect((self.blocks_message_strobe_0, 'strobe'),
(self.inets_dummy_source_0, 'trigger'))
self.msg_connect(
(self.inets_address_check_0, 'address_check_pass_out'),
(self.inets_frame_type_check_0, 'frame_info_in'))
self.msg_connect((self.inets_dummy_source_0, 'output'),
(self.inets_frame_buffer_0, 'enqueue'))
self.msg_connect((self.inets_frame_analysis_0, 'frame_info_out'),
(self.inets_address_check_0, 'frame_info_in'))
self.msg_connect((self.inets_frame_buffer_0, 'dequeue_element'),
(self.inets_framing_0, 'data_in'))
self.msg_connect((self.inets_frame_filter_1, 'frame_info_out'),
(self.inets_sending_0, 'in'))
self.msg_connect((self.inets_frame_index_check_0, 'frame_info_out'),
(self.inets_sending_0, 'in'))
self.msg_connect(
(self.inets_frame_type_check_0, 'data_frame_info_out'),
(self.inets_framing_1, 'data_in'))
self.msg_connect((self.inets_frame_type_check_0, 'ack_frame_info_out'),
(self.inets_timeout_0, 'ack_frame_info_in'))
self.msg_connect((self.inets_framing_0, 'frame_out'),
(self.inets_slide_window_0, 'frame_info_in'))
self.msg_connect((self.inets_framing_1, 'frame_out'),
(self.inets_frame_index_check_0, 'frame_in'))
self.msg_connect((self.inets_receiving_0, 'rx_frame_out'),
(self.inets_frame_analysis_0, 'frame_in'))
self.msg_connect((self.inets_slide_window_0, 'reload_request'),
(self.inets_frame_buffer_0, 'dequeue'))
self.msg_connect((self.inets_slide_window_0, 'frame_info_out'),
(self.inets_frame_filter_1, 'frame_info_in'))
self.msg_connect((self.inets_slide_window_0, 'frame_info_out'),
(self.inets_timeout_0, 'data_frame_info_in'))
self.msg_connect((self.inets_timeout_0, 'frame_info_out'),
(self.inets_slide_window_0, 'ack_info_in'))
def __init__(self,
n_bursts,
n_channels,
freq_delta,
base_freq,
dsp_tuning,
burst_length,
base_time,
hop_time,
post_tuning=False,
tx_gain=0,
verbose=False):
gr.hier_block2.__init__(
self,
"FrequencyHopperSrc",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(1, 1, gr.sizeof_gr_complex),
)
n_samples_total = n_bursts * burst_length
lowest_frequency = base_freq - numpy.floor(n_channels / 2) * freq_delta
self.hop_sequence = [
lowest_frequency + n * freq_delta for n in range(n_channels)
]
numpy.random.shuffle(self.hop_sequence)
# Repeat that:
self.hop_sequence = [
self.hop_sequence[x % n_channels] for x in range(n_bursts)
]
if verbose:
print("Hop Frequencies | Hop Pattern")
print("=================|================================")
for f in self.hop_sequence:
print("{:6.3f} MHz | ".format(f / 1e6), end='')
if n_channels < 50:
print(" " * int((f - base_freq) / freq_delta) + "#")
else:
print("\n")
print("=================|================================")
# There's no real point in setting the gain via tag for this application,
# but this is an example to show you how to do it.
gain_tag = gr.tag_t()
gain_tag.offset = 0
gain_tag.key = pmt.string_to_symbol('tx_command')
gain_tag.value = pmt.to_pmt({'gain': tx_gain})
tag_list = [
gain_tag,
]
for i in range(len(self.hop_sequence)):
time = pmt.cons(
pmt.from_uint64(int(base_time + i * hop_time + 0.01)),
pmt.from_double((base_time + i * hop_time + 0.01) % 1),
)
tune_tag = gr.tag_t()
tune_tag.offset = i * burst_length
# TODO dsp_tuning should also be able to do post_tuning
if i > 0 and post_tuning and not dsp_tuning:
tune_tag.offset -= 1 # Move it to last sample of previous burst
if dsp_tuning:
tune_tag.key = pmt.string_to_symbol('tx_command')
tune_tag.value = pmt.to_pmt({
'lo_freq':
base_freq,
'dsp_freq':
base_freq - self.hop_sequence[i]
})
tune_tag.value = pmt.dict_add(tune_tag.value,
pmt.intern("time"), time)
else:
tune_tag.key = pmt.string_to_symbol('tx_command')
tune_tag.value = pmt.to_pmt({'freq': self.hop_sequence[i]})
tune_tag.value = pmt.dict_add(tune_tag.value,
pmt.intern('time'), time)
tag_list.append(tune_tag)
length_tag = gr.tag_t()
length_tag.offset = i * burst_length
length_tag.key = pmt.string_to_symbol('packet_len')
length_tag.value = pmt.from_long(burst_length)
tag_list.append(length_tag)
time_tag = gr.tag_t()
time_tag.offset = i * burst_length
time_tag.key = pmt.string_to_symbol('tx_time')
time_tag.value = pmt.make_tuple(pmt.car(time), pmt.cdr(time))
tag_list.append(time_tag)
tag_source = blocks.vector_source_c((1.0, ) * n_samples_total,
repeat=False,
tags=tag_list)
mult = blocks.multiply_cc()
self.connect(self, mult, self)
self.connect(tag_source, (mult, 1))
def __init__(self):
gr.top_block.__init__(self, "Wifi Tx")
Qt.QWidget.__init__(self)
self.setWindowTitle("Wifi Tx")
qtgui.util.check_set_qss()
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "wifi_tx")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.tx_gain = tx_gain = 0.75
self.samp_rate = samp_rate = 10e6
self.pdu_length = pdu_length = 500
self.out_buf_size = out_buf_size = 96000
self.lo_offset = lo_offset = 0
self.interval = interval = 300
self.freq = freq = 5890000000
self.encoding = encoding = 0
##################################################
# Blocks
##################################################
self._tx_gain_range = Range(0, 1, 0.01, 0.75, 200)
self._tx_gain_win = RangeWidget(self._tx_gain_range, self.set_tx_gain,
"tx_gain", "counter_slider", float)
self.top_layout.addWidget(self._tx_gain_win)
self._samp_rate_options = [5e6, 10e6, 20e6]
self._samp_rate_labels = ["5 MHz", "10 MHz", "20 MHz"]
self._samp_rate_tool_bar = Qt.QToolBar(self)
self._samp_rate_tool_bar.addWidget(Qt.QLabel("samp_rate" + ": "))
self._samp_rate_combo_box = Qt.QComboBox()
self._samp_rate_tool_bar.addWidget(self._samp_rate_combo_box)
for label in self._samp_rate_labels:
self._samp_rate_combo_box.addItem(label)
self._samp_rate_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._samp_rate_combo_box, "setCurrentIndex",
Qt.Q_ARG("int", self._samp_rate_options.index(i)))
self._samp_rate_callback(self.samp_rate)
self._samp_rate_combo_box.currentIndexChanged.connect(
lambda i: self.set_samp_rate(self._samp_rate_options[i]))
self.top_layout.addWidget(self._samp_rate_tool_bar)
self._pdu_length_range = Range(0, 1500, 1, 500, 200)
self._pdu_length_win = RangeWidget(self._pdu_length_range,
self.set_pdu_length, "pdu_length",
"counter_slider", int)
self.top_layout.addWidget(self._pdu_length_win)
self._lo_offset_options = (
0,
6e6,
11e6,
)
self._lo_offset_labels = (
str(self._lo_offset_options[0]),
str(self._lo_offset_options[1]),
str(self._lo_offset_options[2]),
)
self._lo_offset_tool_bar = Qt.QToolBar(self)
self._lo_offset_tool_bar.addWidget(Qt.QLabel("lo_offset" + ": "))
self._lo_offset_combo_box = Qt.QComboBox()
self._lo_offset_tool_bar.addWidget(self._lo_offset_combo_box)
for label in self._lo_offset_labels:
self._lo_offset_combo_box.addItem(label)
self._lo_offset_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._lo_offset_combo_box, "setCurrentIndex",
Qt.Q_ARG("int", self._lo_offset_options.index(i)))
self._lo_offset_callback(self.lo_offset)
self._lo_offset_combo_box.currentIndexChanged.connect(
lambda i: self.set_lo_offset(self._lo_offset_options[i]))
self.top_layout.addWidget(self._lo_offset_tool_bar)
self._interval_range = Range(10, 1000, 1, 300, 200)
self._interval_win = RangeWidget(self._interval_range,
self.set_interval, "interval",
"counter_slider", int)
self.top_layout.addWidget(self._interval_win)
self._freq_options = [
2412000000.0, 2417000000.0, 2422000000.0, 2427000000.0,
2432000000.0, 2437000000.0, 2442000000.0, 2447000000.0,
2452000000.0, 2457000000.0, 2462000000.0, 2467000000.0,
2472000000.0, 2484000000.0, 5170000000.0, 5180000000.0,
5190000000.0, 5200000000.0, 5210000000.0, 5220000000.0,
5230000000.0, 5240000000.0, 5250000000.0, 5260000000.0,
5270000000.0, 5280000000.0, 5290000000.0, 5300000000.0,
5310000000.0, 5320000000.0, 5500000000.0, 5510000000.0,
5520000000.0, 5530000000.0, 5540000000.0, 5550000000.0,
5560000000.0, 5570000000.0, 5580000000.0, 5590000000.0,
5600000000.0, 5610000000.0, 5620000000.0, 5630000000.0,
5640000000.0, 5660000000.0, 5670000000.0, 5680000000.0,
5690000000.0, 5700000000.0, 5710000000.0, 5720000000.0,
5745000000.0, 5755000000.0, 5765000000.0, 5775000000.0,
5785000000.0, 5795000000.0, 5805000000.0, 5825000000.0,
5860000000.0, 5870000000.0, 5880000000.0, 5890000000.0,
5900000000.0, 5910000000.0, 5920000000.0
]
self._freq_labels = [
' 1 | 2412.0 | 11g', ' 2 | 2417.0 | 11g', ' 3 | 2422.0 | 11g',
' 4 | 2427.0 | 11g', ' 5 | 2432.0 | 11g', ' 6 | 2437.0 | 11g',
' 7 | 2442.0 | 11g', ' 8 | 2447.0 | 11g', ' 9 | 2452.0 | 11g',
' 10 | 2457.0 | 11g', ' 11 | 2462.0 | 11g', ' 12 | 2467.0 | 11g',
' 13 | 2472.0 | 11g', ' 14 | 2484.0 | 11g', ' 34 | 5170.0 | 11a',
' 36 | 5180.0 | 11a', ' 38 | 5190.0 | 11a', ' 40 | 5200.0 | 11a',
' 42 | 5210.0 | 11a', ' 44 | 5220.0 | 11a', ' 46 | 5230.0 | 11a',
' 48 | 5240.0 | 11a', ' 50 | 5250.0 | 11a', ' 52 | 5260.0 | 11a',
' 54 | 5270.0 | 11a', ' 56 | 5280.0 | 11a', ' 58 | 5290.0 | 11a',
' 60 | 5300.0 | 11a', ' 62 | 5310.0 | 11a', ' 64 | 5320.0 | 11a',
'100 | 5500.0 | 11a', '102 | 5510.0 | 11a', '104 | 5520.0 | 11a',
'106 | 5530.0 | 11a', '108 | 5540.0 | 11a', '110 | 5550.0 | 11a',
'112 | 5560.0 | 11a', '114 | 5570.0 | 11a', '116 | 5580.0 | 11a',
'118 | 5590.0 | 11a', '120 | 5600.0 | 11a', '122 | 5610.0 | 11a',
'124 | 5620.0 | 11a', '126 | 5630.0 | 11a', '128 | 5640.0 | 11a',
'132 | 5660.0 | 11a', '134 | 5670.0 | 11a', '136 | 5680.0 | 11a',
'138 | 5690.0 | 11a', '140 | 5700.0 | 11a', '142 | 5710.0 | 11a',
'144 | 5720.0 | 11a', '149 | 5745.0 | 11a (SRD)',
'151 | 5755.0 | 11a (SRD)', '153 | 5765.0 | 11a (SRD)',
'155 | 5775.0 | 11a (SRD)', '157 | 5785.0 | 11a (SRD)',
'159 | 5795.0 | 11a (SRD)', '161 | 5805.0 | 11a (SRD)',
'165 | 5825.0 | 11a (SRD)', '172 | 5860.0 | 11p',
'174 | 5870.0 | 11p', '176 | 5880.0 | 11p', '178 | 5890.0 | 11p',
'180 | 5900.0 | 11p', '182 | 5910.0 | 11p', '184 | 5920.0 | 11p'
]
self._freq_tool_bar = Qt.QToolBar(self)
self._freq_tool_bar.addWidget(Qt.QLabel("freq" + ": "))
self._freq_combo_box = Qt.QComboBox()
self._freq_tool_bar.addWidget(self._freq_combo_box)
for label in self._freq_labels:
self._freq_combo_box.addItem(label)
self._freq_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._freq_combo_box, "setCurrentIndex",
Qt.Q_ARG("int", self._freq_options.index(i)))
self._freq_callback(self.freq)
self._freq_combo_box.currentIndexChanged.connect(
lambda i: self.set_freq(self._freq_options[i]))
self.top_layout.addWidget(self._freq_tool_bar)
self._encoding_options = [0, 1, 2, 3, 4, 5, 6, 7]
self._encoding_labels = [
"BPSK 1/2", "BPSK 3/4", "QPSK 1/2", "QPSK 3/4", "16QAM 1/2",
"16QAM 3/4", "64QAM 2/3", "64QAM 3/4"
]
self._encoding_group_box = Qt.QGroupBox("encoding")
self._encoding_box = Qt.QHBoxLayout()
class variable_chooser_button_group(Qt.QButtonGroup):
def __init__(self, parent=None):
Qt.QButtonGroup.__init__(self, parent)
@pyqtSlot(int)
def updateButtonChecked(self, button_id):
self.button(button_id).setChecked(True)
self._encoding_button_group = variable_chooser_button_group()
self._encoding_group_box.setLayout(self._encoding_box)
for i, label in enumerate(self._encoding_labels):
radio_button = Qt.QRadioButton(label)
self._encoding_box.addWidget(radio_button)
self._encoding_button_group.addButton(radio_button, i)
self._encoding_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._encoding_button_group, "updateButtonChecked",
Qt.Q_ARG("int", self._encoding_options.index(i)))
self._encoding_callback(self.encoding)
self._encoding_button_group.buttonClicked[int].connect(
lambda i: self.set_encoding(self._encoding_options[i]))
self.top_layout.addWidget(self._encoding_group_box)
self.wifi_phy_hier_0 = wifi_phy_hier(
bandwidth=10e6,
chan_est=0,
encoding=encoding,
frequency=5.89e9,
sensitivity=0.56,
)
self.uhd_usrp_sink_0 = uhd.usrp_sink(
",".join(('', "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
'packet_len',
)
self.uhd_usrp_sink_0.set_subdev_spec('A:B', 0)
self.uhd_usrp_sink_0.set_samp_rate(samp_rate)
self.uhd_usrp_sink_0.set_time_now(uhd.time_spec(time.time()),
uhd.ALL_MBOARDS)
self.uhd_usrp_sink_0.set_center_freq(
uhd.tune_request(freq,
rf_freq=freq - lo_offset,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0)
self.uhd_usrp_sink_0.set_normalized_gain(tx_gain, 0)
self.ieee802_11_mac_0 = ieee802_11.mac(
([0x23, 0x23, 0x23, 0x23, 0x23, 0x23]),
([0x42, 0x42, 0x42, 0x42, 0x42, 0x42]),
([0xff, 0xff, 0xff, 0xff, 0xff, 255]))
self.foo_packet_pad2_0 = foo.packet_pad2(False, False, 0.01, 100, 1000)
(self.foo_packet_pad2_0).set_min_output_buffer(96000)
self.blocks_socket_pdu_0 = blocks.socket_pdu("UDP_SERVER", '', '52001',
10000, False)
self.blocks_null_source_0 = blocks.null_source(gr.sizeof_gr_complex *
1)
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc((0.6, ))
(self.blocks_multiply_const_vxx_0).set_min_output_buffer(100000)
self.blocks_message_strobe_0_0 = blocks.message_strobe(
pmt.intern("".join("x" for i in range(pdu_length))), interval)
##################################################
# Connections
##################################################
self.msg_connect((self.blocks_message_strobe_0_0, 'strobe'),
(self.ieee802_11_mac_0, 'app in'))
self.msg_connect((self.blocks_socket_pdu_0, 'pdus'),
(self.ieee802_11_mac_0, 'app in'))
self.msg_connect((self.ieee802_11_mac_0, 'phy out'),
(self.wifi_phy_hier_0, 'mac_in'))
self.msg_connect((self.wifi_phy_hier_0, 'mac_out'),
(self.ieee802_11_mac_0, 'phy in'))
self.connect((self.blocks_multiply_const_vxx_0, 0),
(self.foo_packet_pad2_0, 0))
self.connect((self.blocks_null_source_0, 0), (self.wifi_phy_hier_0, 0))
self.connect((self.foo_packet_pad2_0, 0), (self.uhd_usrp_sink_0, 0))
self.connect((self.wifi_phy_hier_0, 0),
(self.blocks_multiply_const_vxx_0, 0))
def text_changed(self):
s = self.text().toUtf8()
nvec = numpy.fromstring((s), dtype=numpy.uint8, count=len(s))
vec = pmt.to_pmt(nvec)
self.message_port_pub(pmt.intern("pdus"), pmt.cons(pmt.PMT_NIL, vec))
self.clear()
