def run(self):
pkt = self.socket.recv(1000)
paquete_llegada = pickle.loads(pkt)
# MAC requests an incoming packet to the PHY
if (paquete_llegada["TIPO"] == "COLA"):
tipo_pkt = paquete_llegada["DATOS"]
len_data = self.data.longitud()
len_ack = self.ack.longitud()
len_rts = self.rts.longitud()
len_cts = self.cts.longitud()
if (tipo_pkt
== "DATA") and len_data > 0: # There are Data packets?
self.data.elementos.reverse()
x = self.data.read(0)
phy_pkt = plcp.crear_paquete("SI", x)
self.data.pop()
self.data.elementos.reverse()
elif tipo_pkt == "ACK" and len_ack > 0: # There are ACK packets?
self.ack.elementos.reverse()
x = self.ack.read(0)
phy_pkt = plcp.crear_paquete("SI", x)
self.ack.pop()
self.ack.elementos.reverse()
elif tipo_pkt == "RTS" and len_rts > 0: # There are RTS packets?
self.rts.elementos.reverse()
x = self.rts.read(0)
phy_pkt = plcp.crear_paquete("SI", x)
self.rts.pop()
self.rts.elementos.reverse()
elif tipo_pkt == "CTS" and len_cts > 0: # There are CTS packets?
self.cts.elementos.reverse()
x = self.cts.read(0)
phy_pkt = plcp.crear_paquete("SI", x)
self.cts.pop()
self.cts.elementos.reverse()
else: # There are not packets
phy_pkt = plcp.crear_paquete("NO", [])
plcp.enviar_a_mac(
self.socket,
phy_pkt) # Send the result (PHY packet) to MAC layer
self.socket.close()
# PHY packet generator script. It sends an 802.11 frame simulating its arrival from the wireless medium
if (paquete_llegada["TIPO"] == "DATA"
or paquete_llegada["TIPO"] == "DATA_FRAG"):
if paquete_llegada["DATOS"]["INFO"][
"mac_add1"] == self.my_mac: # Is the data packet addressed to this node?
self.data.push(paquete_llegada["DATOS"])
self.socket.close()
if (paquete_llegada["TIPO"] == "ACK"):
if paquete_llegada["DATOS"]["INFO"][
"RX_add"] == self.my_mac: # Is the ACK addressed to this node?
self.ack.push(paquete_llegada["DATOS"])
self.socket.close()
if (paquete_llegada["TIPO"] == "RTS"): #It is a RTS
self.rts.push(paquete_llegada["DATOS"])
self.socket.close()
if (paquete_llegada["TIPO"] == "CTS"): #It is a CTS
self.cts.push(paquete_llegada["DATOS"])
self.socket.close()
if (paquete_llegada["TIPO"] == "BEACON"): #It is a BEACON
beacon = paquete_llegada["DATOS"]
beacon = beacon["INFO"]
msg = plcp.nuevo_beacon()
msg["MAC"] = beacon["mac_add2"]
msg["timestamp"] = beacon["timestamp"]
msg["BI"] = beacon["BI"]
msg["OFFSET"] = time.time() - beacon["timestamp"]
x = self.bcn.longitud()
actualizado = False
# Update the beacon list
for i in range(0, x):
if msg["MAC"] == self.bcn.read(i)["MAC"]:
self.bcn.quitar(i)
self.bcn.insert(i, msg)
actualizado = True
if actualizado == False:
self.bcn.insert(x + 1, msg)
if (paquete_llegada["TIPO"] == "OTHER"):
#print "No packet arrived"
self.socket.close()
#DEBUG
print "=========== BUFFER STATUS ==========="
print "DATA [%i]" % self.data.longitud()
print "ACK [%i]" % self.ack.longitud()
print "RTS [%i]" % self.rts.longitud()
print "CTS [%i]" % self.cts.longitud()
print "====================================="
print "\n\n"
# Beacon list
print "========= NEIGHBOR NODES INFORMATION =========="
for i in range(0, self.bcn.longitud()):
leido = self.bcn.read(i)
print "[MAC = %s]\t [Timestamp = %s]\t [Beacon Interval = %s]\t [OFFSET = %s]" % (
mac.which_dir(leido["MAC"]), leido["timestamp"], leido["BI"],
leido["OFFSET"])
print "==============================================="
def run(self):
pkt = self.socket.recv(1000)
paquete_llegada = pickle.loads(pkt)
# MAC requests an incoming packet to the PHY
if (paquete_llegada["TIPO"]=="COLA"):
tipo_pkt = paquete_llegada["DATOS"]
len_data = self.data.longitud()
len_ack = self.ack.longitud()
len_rts = self.rts.longitud()
len_cts = self.cts.longitud()
if (tipo_pkt == "DATA") and len_data>0: # There are Data packets?
self.data.elementos.reverse()
x=self.data.read(0)
phy_pkt = plcp.crear_paquete("SI",x)
self.data.pop()
self.data.elementos.reverse()
elif tipo_pkt == "ACK" and len_ack>0: # There are ACK packets?
self.ack.elementos.reverse()
x=self.ack.read(0)
phy_pkt = plcp.crear_paquete("SI",x)
self.ack.pop()
self.ack.elementos.reverse()
elif tipo_pkt == "RTS" and len_rts>0: # There are RTS packets?
self.rts.elementos.reverse()
x=self.rts.read(0)
phy_pkt = plcp.crear_paquete("SI",x)
self.rts.pop()
self.rts.elementos.reverse()
elif tipo_pkt == "CTS" and len_cts>0: # There are CTS packets?
self.cts.elementos.reverse()
x=self.cts.read(0)
phy_pkt = plcp.crear_paquete("SI",x)
self.cts.pop()
self.cts.elementos.reverse()
else: # There are not packets
phy_pkt = plcp.crear_paquete("NO",[])
plcp.enviar_a_mac(self.socket,phy_pkt) # Send the result (PHY packet) to MAC layer
self.socket.close()
# PHY packet generator script. It sends an 802.11 frame simulating its arrival from the wireless medium
if (paquete_llegada["TIPO"]=="DATA" or paquete_llegada["TIPO"]=="DATA_FRAG"):
if paquete_llegada["DATOS"]["INFO"]["mac_add1"] == self.my_mac: # Is the data packet addressed to this node?
self.data.push(paquete_llegada["DATOS"])
self.socket.close()
if (paquete_llegada["TIPO"]=="ACK"):
if paquete_llegada["DATOS"]["INFO"]["RX_add"] == self.my_mac:# Is the ACK addressed to this node?
self.ack.push(paquete_llegada["DATOS"])
self.socket.close()
if (paquete_llegada["TIPO"]=="RTS"): #It is a RTS
self.rts.push(paquete_llegada["DATOS"])
self.socket.close()
if (paquete_llegada["TIPO"]=="CTS"): #It is a CTS
self.cts.push(paquete_llegada["DATOS"])
self.socket.close()
if (paquete_llegada["TIPO"]=="BEACON"): #It is a BEACON
beacon = paquete_llegada["DATOS"]
beacon = beacon["INFO"]
msg = plcp.nuevo_beacon()
msg["MAC"]= beacon["mac_add2"]
msg["timestamp"]=beacon["timestamp"]
msg["BI"]=beacon["BI"]
msg["OFFSET"]=time.time() - beacon["timestamp"]
x = self.bcn.longitud()
actualizado = False
# Update the beacon list
for i in range(0,x):
if msg["MAC"]==self.bcn.read(i)["MAC"]:
self.bcn.quitar(i)
self.bcn.insert(i,msg)
actualizado = True
if actualizado == False:
self.bcn.insert(x+1,msg)
if (paquete_llegada["TIPO"]=="OTHER"):
#print "No packet arrived"
self.socket.close()
#DEBUG
print "=========== BUFFER STATUS ==========="
print "DATA [%i]"%self.data.longitud()
print "ACK [%i]"%self.ack.longitud()
print "RTS [%i]"%self.rts.longitud()
print "CTS [%i]"%self.cts.longitud()
print "====================================="
print "\n\n"
# Beacon list
print "========= NEIGHBOR NODES INFORMATION =========="
for i in range (0,self.bcn.longitud()):
leido = self.bcn.read(i)
print "[MAC = %s]\t [Timestamp = %s]\t [Beacon Interval = %s]\t [OFFSET = %s]" %(mac.which_dir(leido["MAC"]),leido["timestamp"],leido["BI"],leido["OFFSET"])
print "==============================================="
def main():
def send_pkt(puerto, eof=False):
return tb.txpath.send_pkt(puerto, eof)
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
parser.add_option("-a", "--args", type="string", default="",
help="UHD device address args [default=%default]")
parser.add_option("", "--spec", type="string", default=None,
help="Subdevice of UHD device where appropriate")
parser.add_option("-A", "--antenna", type="string", default=None,
help="select Rx Antenna where appropriate")
parser.add_option("-f", "--freq", type="eng_float",
default = 2.412e9, help="set USRP2 carrier frequency, [default=%default]",
metavar="FREQ")
parser.add_option("-W", "--bandwidth", type="eng_float",
default=10000000,
help="set symbol bandwidth [default=%default]\
20 MHz -> 802.11a/g, OFDM-symbolduration=4us, \
10 MHz -> 802.11p, OFDM-symbolduration=8us")
parser.add_option("", "--regime", type="string", default="1",
help="set OFDM coderegime, [default=%default]\
1 -> 6 (3) Mbit/s (BPSK r=0.5), \
2 -> 9 (4.5) Mbit/s (BPSK r=0.75), \
3 -> 12 (6) Mbit/s (QPSK r=0.5), \
4 -> 18 (9) Mbit/s (QPSK r=0.75), \
5 -> 24 (12) Mbit/s (QAM16 r=0.5), \
6 -> 36 (18) Mbit/s (QAM16 r=0.75), \
7 -> 48 (24) Mbit/s (QAM64 r=0.66), \
8 -> 54 (27) Mbit/s (QAM64 r=0.75)")
parser.add_option("-G", "--txgain", type="int", default=10 , help = "set USRP2 Tx GAIN in [dB] [default=%default]")
parser.add_option("-g", "--gain", type="int", default=30 , help = "set USRP2 Rx GAIN in [dB] [default=%default]")
parser.add_option("-n", "--norm", type="eng_float", default=0.3 , help="set gain factor for complex baseband floats [default=%default]")
parser.add_option("-r", "--repetition", type="int", default=1 , help="set number of frame-copies to send, 0=infinite [default=%default] ")
parser.add_option("-l", "--log", action="store_true", default=False, help="write debug-output of individual blocks to disk")
parser.add_option("", "--PHYport", type="int", default=8000 , help="Port used for MAC-->PHY communication [default=%default] ")
parser.add_option("", "--tune-delay", type="eng_float", default=1e-4, metavar="SECS",
help="Carrier sensing parameter. Time to delay (in seconds) after changing frequency [default=%default]")
parser.add_option("", "--dwell-delay", type="eng_float", default=1e-3, metavar="SECS",
help="Carrier sensing parameter. Time to dwell (in seconds) at a given frequncy [default=%default]")
parser.add_option("-F", "--fft-size", type="int", default=256,
help="specify number of FFT bins [default=%default]")
parser.add_option("-d", "--decim", type="intx", default=16,
help="set the decimation value [default=%default]")
parser.add_option("", "--real-time", action="store_true", default=False,
help="Attempt to enable real-time scheduling")
parser.add_option('-v', "--verbose", action="store_true", default=False,
help="Print timming information, [default=%default]")
(options, args) = parser.parse_args ()
# Stream sockets to ensure no packet loss during PHY<-->MAC communication
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((socket.gethostname(), options.PHYport))
s_cca = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.listen(1) # PHY is ready to attend MAC requests
print '\n',"-------------------------"
print " PHY (TX) layer running ..."
print " (Ctrl + C) to exit"
print "-------------------------",'\n'
# Initial values of variables used in time measurement
N_sym_ant=4 # OFDM symbols of the previous packet sent
N_sensados = 0 # Number of power measurements
N_paquetes = 0 # Number of packets sent
tiempo_socket = 0 # Instant time of socket communication
t_socket_TOTAL = 0 # Total time of socket communication
T_sensado_USRP2 = 0 # Time of the USRP2 measuring the power
T_sensado_PHY = 0 # Time elapsed in PHY layer due to a carrier sensing request
T_transmitir_USRP2 = 0 # USRP2 TX time
T_configurar_grafo = 0 # Time due to USRP2 graph management
T_transmitir_PHY = 0 # Time elapsed in PHY layer due to a packet tx request
first_time = True # Is the first time to transmit?
fg_cca = sense_block(options) # Set up the carrier sensing block for the first time.
while 1:
socket_cliente, datos_cliente = server.accept() # Waiting a request from the MAC layer
paquete_llegada=plcp.recibir_de_mac(socket_cliente) # Packet received from MAC
if (paquete_llegada["TIPO"]=="PKT"):
t_socket = time.time()-paquete_llegada["DATOS"]["INFO"]["timestamp"]
t_socket_TOTAL =t_socket_TOTAL + t_socket #Update the time used in the socket communication.
# If it is a 'send packet' request, it checks if the TX graph needs a reconfiguration
if (paquete_llegada["TIPO"]=="PKT") and first_time == False and (N_sym_ant == paquete_llegada["DATOS"]["INFO"]["N_sym"]) == False:
tb.stop() # It is necessary to switch the USRP2 functionality (802.11 transmitter or Carrier Sensing Function)
# Carrier sensing request
if (paquete_llegada["TIPO"]=="CCA"):
t_sensadoA = time.time()
fg_cca.start()
t_reconfig = time.time()-t_sensadoA
potencia_sensada=main_loop(fg_cca) # Power measurement
fg_cca.stop()
fg_cca.wait() # Wait until the USRP2 returns the Power measurement
t_sensadoB = time.time()
# PHY responds with the power measured to the MAC
paquete=plcp.crear_paquete("CCA",potencia_sensada)
plcp.enviar_a_mac(socket_cliente,paquete)
t_sensadoC = time.time()
T_sensado_USRP2 = T_sensado_USRP2 + (t_sensadoB - t_sensadoA)
T_sensado_PHY = T_sensado_PHY + (t_sensadoC - t_sensadoA)
N_sensados +=1
if options.verbose: print "Time elapsed on graph configuration (Carrier Sensing) = \t", t_reconfig
# Send packet request
if (paquete_llegada["TIPO"]=="PKT"):
t_enviarA = time.time()
leido=paquete_llegada["DATOS"] # Copy the packet to send from the MAC message
info = leido["INFO"]
N_sym=info["N_sym"] # Read N_sym and add N_sym to options
mod = info["modulation"]
# FIX ME! Another way to update N_sym and modulation values?
parser.add_option("-T", "--nsym", type="int", default=N_sym)
parser.add_option("", "--modulation", type="string", default=mod)
(options, args) = parser.parse_args ()
# Check if the OFDM code regime or the amount of OFDM symbols to transmit differs from the last packet sent
if first_time == True or (N_sym_ant == paquete_llegada["DATOS"]["INFO"]["N_sym"]) == False:
#print "Re-setting USRP2 graph!"
tb = transmitter_block(options) # If necessary, update the transmit flow-graph depending to the new OFDM parameters
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: failed to enable realtime scheduling"
t_2 = time.time()
tb.start() # Send packet procedure starts
t_enviarB= time.time()
send_pkt(leido,eof=False) # 'leido' is a dictionary which contents the packet to transmit and other information
send_pkt("",eof=True)
t_enviarC = time.time()
tb.wait() # Wait until USRP2 finishes the TX-graph
t_enviarD= time.time()
if options.verbose: print "Time elapsed on graph configuration (TX Packet) = \t", (t_enviarB - t_2)
T_transmitir_USRP2 = T_transmitir_USRP2 + t_enviarC-t_enviarB
T_configurar_grafo = T_configurar_grafo + t_enviarD-t_enviarA - (t_enviarC-t_enviarB)
T_transmitir_PHY = T_transmitir_PHY + t_enviarD-t_enviarA
# set values for the next packet tx request
first_time=False
N_sym_ant = N_sym # Keep a record of the OFDM symbols' Number
N_paquetes += 1
if options.verbose:
print "===================== Average statistics ===================="
print "Number of Carrier Sensing Requests = ",N_sensados
if N_sensados>0:
print "Time spent by USRP2 on sensing channel = \t",T_sensado_USRP2/N_sensados
print "Time spent by PHY layer on sensing channel = \t",T_sensado_PHY/N_sensados
print "============================================================="
print "Number of packets transmitted = ",N_paquetes
if N_paquetes>1:
print "Time spent by USRP2 on sending a packet = \t",T_transmitir_USRP2/N_paquetes
print "Time spent by USRP2 on configuring the graphs\t",T_configurar_grafo/N_paquetes
print "Time spent by PHY on sending a packet = \t",T_transmitir_PHY/N_paquetes
print "Time spent on Socket Communication = \t", t_socket_TOTAL/N_paquetes
print "============================================================="
