def main():
""" Parser Options """
parser = OptionParser (option_class=eng_option)
MimoMPIF.add_parser_options (parser)
if not parser.has_option("--phy-addr"):
parser.add_option("", "--phy-addr", type="string", default="0.0.0.0", \
help="set address for PHY [default=%default]")
(options, args) = parser.parse_args ()
if len(args)!=0:
parser.print_help()
sys.exit(1)
global RATE_LIMIT
if (options.nchannels == 4): RATE_LIMIT = 32
elif (options.nchannels == 2): RATE_LIMIT = 16
elif (options.nchannels == 1): RATE_LIMIT = 8
mac = mimo.mac(options.phy_addr, options.mac_port)
mac.start()
#f = FuncThread(send_data, "tx-data", mac)
f = FuncThread(send_80211data, "tx-data", mac)
f.setDaemon(1)
g = FuncThread(recv_data, "rx-data", mac)
g.setDaemon(1)
h = FuncThread(recv_ctrl, "rx-ctrl", mac)
h.setDaemon(1)
for x in [f,g,h]: x.start()
#for x in [g,h]: x.start()
raw_input("Press Enter to quit:\n")
mac.shutdown()
p = persist() # start a persitent thread
def start(self, startgui=True):
self.isalive = True
f = FuncThread(self.monitor)
f.setDaemon(1)
g = None
if not self.disable:
if window.wxapp is None: window.wxapp = wx.App(0)
g = FuncThread(self.start_wxApp)
g.setDaemon(1)
if self.control: self.control.Show(True)
if startgui: g.start()
f.start()
return g
def TestTx():
""" Parser Options """
parser = OptionParser (option_class=eng_option)
RadioTx.add_parser_options (parser)
(options, args) = parser.parse_args ()
if len(args)!=0:
parser.print_help()
sys.exit(1)
print "TestTx\n=========="
tb = gr.top_block()
tx = RadioTx(options)
tb.connect(tx)
#T, w, C = 10.0, 100.0e3, 100
T, w, C = 10.0, 40.0e3, 100
A = 4000
if SEND_MIMO_TRAINING:
T = 10.0
s = "hi"*4
txvector = mimo.txvector()
txvector.set_length(len(s) )
phy = mimo.tx(options.nchannels)
phy.configure(txvector)
phy.set_gain(10000)
phy.set_upsampling_factor(2)
phy.transmit(s)
m = phy.outputQ().delete_head()
print "created message ... %d samples"%(m.length()/gr.sizeof_gr_complex/options.nchannels)
else:
P = min(T, C/w)
k = max(1, int(T/P) )
s = Signal()
s.setData(make_exponential(A, P, w, options.sample_rate) )
m = gr.message_from_string(s.string(k), 0, 1, len(s.vector())*k )
print "created message ... %d samples"%(int(k*P*options.sample_rate) )
interval = 0.2
g = FuncThread(send_msg, "send msg", m, tx.pad.inputQ(), interval)
g.setDaemon(1)
g.start()
stoptime = T+5.0
f = FuncThread(send_stoprf, "stop rf", tx, stoptime)
f.setDaemon(1)
f.start()
print "running ..."
tb.run()
print "stoppping ..."
def main():
'''
tb = gr.top_block()
src_data = (-3, 4, -5.5, 2, 3)
src = gr.vector_source_f (src_data)
sqr = howto.square_ff ()
dst = gr.vector_sink_f ()
tb.connect (src, sqr)
tb.connect (sqr, dst)
tb.run ()
result_data = dst.data ()
print result_data
print '\n'
src_data = (-3, 4, -5.5, 2, 3)
src = gr.vector_source_f (src_data)
sqr = howto.square2_ff ()
dst = gr.vector_sink_f ()
tb.connect (src, sqr)
tb.connect (sqr, dst)
tb.run ()
result_data = dst.data ()
print result_data
ofdm_tx = howto.ofdm_tx(0)
print ofdm_tx
'''
tb = gr.top_block()
ofdm_tx = howto.ofdm_tx(0, 4)
#dst = gr.vector_sink_c ()
dst = gr.file_sink(gr.sizeof_gr_complex, 'outdata.dat')
tb.connect (ofdm_tx, dst)
print "connect"
f = FuncThread(bar, "bar", ofdm_tx)
f.setDaemon(1)
f.start()
g = FuncThread(result, "result", dst)
g.setDaemon(1)
g.start()
tb.run()
print "run"
sleep(400)
'''
def TestDC():
""" Parser Options """
parser = OptionParser (option_class=eng_option)
RadioRx.add_parser_options (parser)
(options, args) = parser.parse_args ()
if len(args)!=0:
parser.print_help()
sys.exit(1)
print "TestRx\n=========="
tb = gr.top_block()
rx = gr.vector_sink_c()
rf = RadioRx(options)
tb.connect(rf,rx)
stoptime = 20.0
if options.fake_rf:
f = FuncThread(send_stoprf, "stop rf", rf, stoptime)
else:
f = FuncThread(stop_tb, "stop tb", tb, stoptime)
f.setDaemon(1)
f.start()
print "running ..."
tb.run()
print "stoppping ..."
n = numpy.array(rx.data() )
n = n[len(n)/2:]
print "noise mean =", n.mean()
print "noise var =", n.var()
print "noise std =", n.std()
def TestRx():
""" Parser Options """
parser = OptionParser (option_class=eng_option)
RadioRx.add_parser_options (parser)
(options, args) = parser.parse_args ()
if len(args)!=0:
parser.print_help()
sys.exit(1)
print "TestRx\n=========="
tb = gr.top_block()
rx = gr.vector_sink_c()
rf = RadioRx(options)
tb.connect(rf,rx)
stoptime = 2.0
if options.fake_rf:
f = FuncThread(send_stoprf, "stop rf", rf, stoptime)
else:
f = FuncThread(stop_tb, "stop tb", tb, stoptime)
f.setDaemon(1)
f.start()
print "running ..."
tb.run()
print "stoppping ..."
x = numpy.array(rx.data(), numpy.complex64)
#start, limit = 200, len(x)
start, limit = 200, 1000
L = min(len(x), start+limit)
xdata = x[start:L]
plot(range(len(xdata)), xdata.real )
hold(True)
plot(range(len(xdata)), xdata.imag, 'r')
#plot(numpy.abs(x[start:L] ) )
grid()
print "plotting ..."
show()
print "quitting ..."
fname = "/tmp/uuu"
FILE = open(fname, "w")
format = '<'+"ff"*len(x)
args = tuple(numpy.array((x.real,x.imag)).transpose().flatten() )
s = struct.pack(format, *args )
FILE.write(s)
FILE.close()
def __init__(self):
p = FuncThread(self.run)
p.setDaemon(1)
p.start()
def main():
""" Parser Options """
parser = OptionParser(option_class=eng_option)
MimoManager.add_parser_options(parser)
Channel.add_parser_options(parser)
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
# overwrite fake_rf when --enable-channel is used
if options.enable_channel:
options.fake_rf = True
mgr = MimoManager(options)
phy = MimoTransceiver(options)
phy.rx.packet_detector().set_debug(options.debug)
phy.rx.packet_detector().set_window(64)
phy.rx.packet_detector().set_delay(16)
# phy.rx.packet_detector().set_thresh(0.70)
phy.rx.packet_detector().set_nchannels(options.nchannels)
"""
"""
sys.stderr.write("phy.rx.packet_detector().window() = %s\n" % (phy.rx.packet_detector().window()))
sys.stderr.write("phy.rx.packet_detector().delay() = %s\n" % (phy.rx.packet_detector().delay()))
sys.stderr.write("phy.rx.packet_detector().nchannels() = %s\n" % (phy.rx.packet_detector().nchannels()))
# phy.rx.set_max_buffer_load(0.0)
sys.stderr.write("phy.rx.nrx() = %s\n" % (phy.rx.nrx()))
sys.stderr.write("phy.tx.nrx() = %s\n" % (phy.tx.ntx()))
sys.stderr.write("phy.rx.max_buffer_size() = %s\n" % (phy.rx.max_buffer_size()))
phy.txpath.pad.set_npre(2)
phy.txpath.pad.set_npost(2)
mpif = MimoMPIF(options)
mpif.set_transceiver(phy)
global RATE_LIMIT
if options.nchannels == 4:
RATE_LIMIT = 32
elif options.nchannels == 2:
RATE_LIMIT = 16
elif options.nchannels == 1:
RATE_LIMIT = 8
mpif.start()
phy.start()
mgr.SetMPIF(mpif)
ch = None
if options.fake_rf and options.enable_channel:
Nodb = 10
chmodel = hydra.phy.channel_model()
chmodel.set_noise_power_db(Nodb)
ch = Channel(chmodel, options)
ch.connect_phy(phy)
ch.start()
if not options.enable_socket:
f = FuncThread(bar, "bar", mpif)
f.setDaemon(1)
f.start()
elif mpif.tx.socket_enable():
sys.stderr.write("MPIF TXPORT = %s\n" % (mpif.tx.port()))
sys.stderr.write("MPIF RXPORT = %s\n" % (mpif.rx.port()))
# mgr.run()
g = mgr.start()
if options.disable_gui:
sys.stderr.write("Press Ctrl-c to quit\n")
try:
while 1:
time.sleep(4)
except KeyboardInterrupt:
sys.stderr.write("exiting ...\n")
else:
if g is not None:
g.join()
mgr.stop()
"""
if (len(TxData)>0):
plot(numpy.abs(TxData) )
grid()
show()
"""
if ch is not None:
sys.stderr.write("CALLING Channel.stop()\n")
ch.stop()
sys.stderr.write("CALLING mpif.shutdown()\n")
mpif.shutdown()
for dd in range(8):
time.sleep(0.5)
sys.stderr.write(".")
sys.stderr.write("\n")
p = persist() # start a persitent thread
