Problems with mobility and connection in ap mininet-wifi

[gaegem]

Hi! I’m trying to build a network which emulates an SDN FANET scenario with drones as APs and hosts as Stations. In particular, I’m using meshAP for connection among APs. I want to obtain coverage for stations and routing among APs. I get sone problems with implementing both mobility and wireless connections: I use “get_trace” to have custom mobility (to allow all nodes to follow some coordinates I generate) but I cannot witness connection between stations and APs. If I look into the “iwconfig” of the station, no AP is connected even if it is in the range, neither if I use “addLink” or if I neglect it. Since the stations are not associated, no Packet IN arrives at the controller and the communication cannot happen: when pinging one “sta” to another I get, in fact, Destination Host Unreachable. Moreover I receive some warning about the tx power. To be more exhaustive, I attach the code of the topology and a screen of what happens.

!/usr/bin/python

""" Abbiamo: creazuione e posizionamento+mobilità di AP e sta. Gli ap sono classi OVSBridgeAP , cioè standalone bridge di ovs che possono essere considerati come switch, questo è essenziale per farli riconoscere da Ryu come switch, quindi poterne impostare il datapath id identificatore del singolo switch manualmente e poterlo quindi associare comodamente su Ryu senza alcun binding. """

'Replaying Mobility'

import os import sys import subprocess import shutil import signal import atexit from mininet.node import Controller, RemoteController from mininet.log import setLogLevel, info from mn_wifi.replaying import ReplayingMobility from mn_wifi.cli import CLI from mn_wifi.net import Mininet_wifi from mn_wifi.link import wmediumd, mesh from mn_wifi.wmediumdConnector import interference from mn_wifi.node import OVSBridgeAP from mn_wifi.node import OVSAP from mn_wifi.node import UserAP

Funzione per eseguire lo script di preparazione con parametri "coordinate generator", si passano i parametri utili al generatore di posizioni come argomenti

def run_preparation_script(area_size, num_nodes_per_side, node_spacing, radius, num_points_per_circle, output_folder): script_path = os.path.dirname(os.path.abspath(file)) + '/coordinate_generator.py' info(f"* Esecuzione dello script di preparazione: {script_path}\n") subprocess.run(['python', script_path, '--area-size', str(area_size), '--num-nodes-per-side', str(num_nodes_per_side), '--node-spacing', str(node_spacing), '--radius', str(radius), '--num-points-per-circle', str(num_points_per_circle), '--output-folder', output_folder, '--num-sta', str(num_sta)], check=True)

Parametri del posizionamento e mobilità: viene creata un'area di coverage all'interno della quale vengono disposti a griglia quadrata una serie di droni, che hanno facoltà di muoversi in un intorno circolare ripetto alla posizione iniziale, definita da un raggio; il numero di punti da generare è necessario da definire in modo coerente con la durata della simulazione

area_size = 500 #DA IMPOSTARE TENENDO CONTO DEL NUMERO DI NODI PER LATO E LA DISTANZA TRA DI ESSI num_nodes_per_side = 3 num_sta = 5 node_spacing = 60 #metres radius = 2 #metres, raggio della circonferenza in cui il singolo nodo può muoversi ap_range = node_spacing + radius num_points_per_circle = 150 #punti di posizione da generare per ogni nodo output_folder = os.path.dirname(os.path.abspath(file)) + '/replayingMobilityCustom/' #folder path in cui vengono salvati i file di posizione per ogni nodo avg_speed = 1 #velocità media dei droni speed_sta = 1 #velocità delle sta

Funzione di pulizia per eliminare i file nella directory di output quando il running termina o viene interrotto

def cleanup_output_folder(folder): if os.path.exists(folder): for filename in os.listdir(folder): file_path = os.path.join(folder, filename) if os.path.isfile(file_path): os.unlink(file_path)

        elif os.path.isdir(file_path):
            shutil.rmtree(file_path)
    info(f"* File delle coordinate eliminati.\n")             

funzione per fare il tracking della posizione: esporta le coordinate dai file di testo e le inserisce nella lista dei punti da seguire di ogni nodo

def gettrace(sta, file): file = open(file, 'r') rawdata = file.readlines() file_.close()

sta.p = []
pos = (-1000, 0, 0)
sta.position = pos

for data in raw_data:
    line = data.split()
    x = line[0]  # First Column
    y = line[1]  # Second Column
    pos = float(x), float(y), 0.0
    sta.p.append(pos)

def topology(args): "Create a network." net = Mininet_wifi(link=wmediumd, wmediumd_mode=interference)

info("* Creating nodes\n")

#creazione parametrica delle entità stations in modo parametrico attraverso una lista:
stations = []
for i in range(num_sta):
    station = net.addStation(f'sta{i+1}', ip=f'10.0.0.{i+1}/8', speed=speed_sta)

#creazione delle entità access point in modo parametrico attraverso una lista:
num_aps = num_nodes_per_side*num_nodes_per_side
aps = []  # Lista per memorizzare gli access points 
for i in range(num_aps):       
    ap = net.addAccessPoint(f'ap{i + 1}',wlans=2, ssid=f'ssid{i+1}', mode='g',dpid=f'{i+1}', speed=avg_speed, range=ap_range, txpower=21)       #,cls=OVSBridgeAP,datapath='user'
    aps.append(ap)  
    #ap.setIP(f'10.0.0.{i+1}/24')           , mac=f'00:{i+1}:00:00:00:{i+1}'
    ap.setMAC(f'00:{i+1}:00:00:00:{i+1}')

#creazione dell'entità del controller
c1 = net.addController('c1', controller=RemoteController)

#setting del modello di propagazione
info("* Configuring Propagation Model\n")
net.setPropagationModel(model="logDistance", exp=4.5)

info("* Configuring nodes\n")
net.configureNodes()

info("* Creating links\n")
'''for i in range(num_sta):
    net.addLink(stations[i],aps[i])'''

#for i,sta in enumerate(stations):
    #net.addLink(sta,aps[i])

for i,ap in enumerate(aps):
    net.addLink(ap, intf=f'ap{i+1}-wlan2', cls=mesh, ssid='mesh-ssid', channel=i+1)

"""for i in range(num_aps):
    net.addLink(aps[i], intf=f'ap{i + 1}-wlan2', cls=mesh, ssid='mesh-ssid', channel=5)"""

"""for ap, sta in zip(aps, stations):
    net.addLink(sta, ap)"""

#assegnazione della mobilità alle stations
net.isReplaying = True
path = output_folder
for i, sta in enumerate(stations):
    get_trace(sta, f'{path}node_{i + 1}.txt')  # Carica le tracce di mobilità per ogni station

#assegnazione della mobilità agli ap
for i, ap in enumerate(aps):
    get_trace(ap, f'{path}node_{i + 1}.txt')  # Carica le tracce di mobilità per ogni AP

net.plotGraph(max_x=area_size, max_y=area_size)

#start della rete
info("* Starting network\n")
net.build()
c1.start()  
#print di informazioni riguardanti gli ap
for ap in aps:
    ap.start([c1])  # Avvia ogni AP
    info("{}  dpid{}  IP: {}  MAC: {}\n".format(ap.name, ap.dpid, ap.IP(), ap.MAC()))

info("* Replaying Mobility\n")
ReplayingMobility(net)

info("* Running CLI\n")
CLI(net)

info("* Stopping network\n")
net.stop()

if name == 'main': setLogLevel('info') cleanup_output_folder(output_folder) run_preparation_script(area_size, num_nodes_per_side, node_spacing, radius, num_points_per_circle, output_folder) topology(sys.argv)

[ramonfontes]

Is the signal range proportional to the tx power? As much tx power you have higher is the signal range and vice-versa. I advice you to take a look at the propagation model formula.