improvements on mobility

mininet/net.py

@@ -196,8 +196,8 @@ def __init__(self, topo=None, switch=OVSKernelSwitch,
  self.driver = driver
  self.disableAutoAssociation = disableAutoAssociation
  self.mobilityKwargs = ''
- self._stopMobility = False
- self._startMobility = False
+ self.isMobilityModel = False
+ self.isMobility = False
  self.ppm_is_set = False
  self.noise_threshold = noise_threshold
  self.cca_threshold = cca_threshold
@@ -921,18 +921,17 @@ def build(self):
  int(node.params['range'][wlan])/5
 
  if self.isWiFi and not self.disableAutoAssociation \
- and not mininetWiFi.isMobility:
+ and not self.isMobility:
  mininetWiFi.autoAssociation(self.stations, self.aps)
 
- if self._stopMobility:
- self.mobilityKwargs['plotNodes'] = self.plot_nodes()
- mininetWiFi.stopMobility(self.stations, self.aps,
- **self.mobilityKwargs)
- if self._startMobility:
- mininetWiFi.start_mobility(self.stations, self.aps,
- **self.mobilityKwargs)
+ if self.isMobility:
+ if self.isMobilityModel or mininetWiFi.isVanet:
+ mininetWiFi.start_mobility(**self.mobilityKwargs)
+ else:
+ self.mobilityKwargs['plotNodes'] = self.plot_nodes()
+ mininetWiFi.stopMobility(**self.mobilityKwargs)
 
- if not mininetWiFi.isMobility \
+ if not self.isMobility \
  and mininetWiFi.prop_model_name == \
  'logNormalShadowing':
  import threading
@@ -941,7 +940,7 @@ def build(self):
  thread.daemon = True
  thread.start()
  else:
- if not mininetWiFi.isMobility and mininetWiFi.DRAW \
+ if not self.isMobility and mininetWiFi.DRAW \
  and not mininetWiFi.alreadyPlotted:
  plotNodes = self.plot_nodes()
  self.stations, self.aps = \
@@ -1013,7 +1012,9 @@ def start(self):
  @classmethod
  def seed(cls, seed):
  "Seed"
- mininetWiFi.seed_ = seed
+ kwargs = dict()
+ kwargs['seed'] = seed
+ mininetWiFi.setMobilityParams(**kwargs)
 
  @classmethod
  def roads(cls, nroads):
@@ -1387,18 +1388,20 @@ def mobility(cls, *args, **kwargs):
 
  def startMobility(self, **kwargs):
  "Starts Mobility"
- self._startMobility = True
- mininetWiFi.isMobility = True
+ self.isMobility = True
  if 'repetitions' in kwargs:
  self.repetitions = kwargs['repetitions']
+ if 'model' in kwargs:
+ self.isMobilityModel = True
  self.mobilityKwargs = kwargs
+ kwargs['stations'] = self.stations
+ kwargs['aps'] = self.aps
+ mininetWiFi.setMobilityParams(**kwargs)
 
  def stopMobility(self, **kwargs):
  """Stops Mobility"""
- self._stopMobility = True
- mininetWiFi.isMobility = True
- kwargs['repetitions'] = self.repetitions
- self.mobilityKwargs = kwargs
+ self.mobilityKwargs.update(kwargs)
+ mininetWiFi.setMobilityParams(**kwargs)
 
  def useExternalProgram(self, program, **params):
  """

mininet/wifiMobility.py

@@ -335,8 +335,8 @@ def get_line(cls, node, x1, y1, z1, x2, y2, z2):
  node.points = node.points + points
 
  @classmethod
- def controlled_mobility(cls, init_time=0, final_time=0, stations=None,
- aps=None, connections=[], plotNodes=[], MIN_X=0,
+ def controlled_mobility(cls, init_time=0, final_time=0, stations=[],
+ aps=[], connections=[], plotNodes=[], MIN_X=0,
  MIN_Y=0, MIN_Z=0, MAX_X=0, MAX_Y=0, MAX_Z=0, AC='',
  is3d=False, DRAW=False, repetitions=1, **params):
  """
@@ -360,7 +360,6 @@ def controlled_mobility(cls, init_time=0, final_time=0, stations=None,
  cls.AC = AC
  cls.stations = stations
  cls.aps = aps
-
  nodes = cls.stations + cls.aps + plotNodes
 
  for node in nodes:
@@ -391,11 +390,9 @@ def controlled_mobility(cls, init_time=0, final_time=0, stations=None,
  float(coord_[1].split(',')[0]),
  float(coord_[1].split(',')[1]),
  float(coord_[1].split(',')[2]))
+
  for rep in range(0, repetitions):
- time_ = time()
- end_time = time_ + final_time
- initial_time = time_ + init_time
- current_time = time_
+ t1 = time()
  i = 1
  if rep > 0:
  for node in nodes:
@@ -405,21 +402,21 @@ def controlled_mobility(cls, init_time=0, final_time=0, stations=None,
  node.time = node.startTime
  cls.calculate_diff_time(node)
  while True:
- if time() > end_time or time() < initial_time:
- break
- if time() - current_time >= i:
+ t2 = time()
+ if (t2 - t1) > final_time or (t2 - t1) < init_time:
+ pass
+ if t2 - t1 >= i:
  for node in cls.mobileNodes:
- if time() - current_time >= node.startTime:
- if node.time <= node.endTime:
- if hasattr(node, 'coord'):
- cls.calculate_diff_time(node)
- node.params['position'] = node.points[node.time * node.moveFac]
- if node.time == node.endTime:
- node.params['position'] = node.points[len(node.points)-1]
- else:
- x, y, z = cls.move_node(node)
- node.params['position'] = [x, y, z]
- node.time += 1
+ if (t2 - t1) >= node.startTime and node.time <= node.endTime:
+ if hasattr(node, 'coord'):
+ cls.calculate_diff_time(node)
+ node.params['position'] = node.points[node.time * node.moveFac]
+ if node.time == node.endTime:
+ node.params['position'] = node.points[len(node.points)-1]
+ else:
+ x, y, z = cls.move_node(node)
+ node.params['position'] = [x, y, z]
+ node.time += 1
  if propagationModel.model == 'logNormalShadowing':
  node.getRange(intf=node.params['wlan'][0])
  if DRAW:
@@ -452,7 +449,7 @@ def addNodes(cls, stas, aps):
  cls.mobileNodes = cls.stations
 
  @classmethod
- def models(cls, stations=None, aps=None, model=None, stationaryNodes=None,
+ def models(cls, stations=[], aps=[], model=None, stationaryNodes=[],
  min_v=0, max_v=0, seed=None, connections=None, plotNodes=[],
  MAX_X=0, MAX_Y=0, AC='', DRAW=False, **params):
  """
@@ -472,7 +469,6 @@ def models(cls, stations=None, aps=None, model=None, stationaryNodes=None,
  """
  np.random.seed(seed)
  cls.AC = AC
-
  cls.addNodes(stations, aps)
  nodes = cls.stations + cls.aps + plotNodes
 
@@ -498,7 +494,7 @@ def models(cls, stations=None, aps=None, model=None, stationaryNodes=None,
  info('Warning: running without GUI.\n')
  DRAW = False
 
- if stationaryNodes is not None:
+ if stationaryNodes is not []:
  debug('Configuring the mobility model %s' % model)
 
  if model == 'RandomWalk': # Random Walk model
@@ -522,13 +518,19 @@ def models(cls, stations=None, aps=None, model=None, stationaryNodes=None,
  else:
  raise Exception("Mobility Model not defined or doesn't exist!")
 
+ if 'final_time' in params:
+ current_time = time()
+ while (time() - current_time) < params['init_time']:
+ pass
  if DRAW:
- cls.startMobilityModelGraph(mob, stationaryNodes)
+ cls.startMobilityModelGraph(mob, stationaryNodes,
+ current_time, params['final_time'])
  else:
- cls.startMobilityModelNoGraph(mob, stationaryNodes)
+ cls.startMobilityModelNoGraph(mob, stationaryNodes,
+ current_time, params['final_time'])
 
  @classmethod
- def startMobilityModelGraph(cls, mob, nodes):
+ def startMobilityModelGraph(cls, mob, nodes, current_time, final_time):
  """
  Useful for plotting graphs
 
@@ -545,11 +547,13 @@ def startMobilityModelGraph(cls, mob, nodes):
  plot2d.updateCircleRadius(node)
  plot2d.graphUpdate(node)
  eval(cls.continuePlot)
+ if final_time is not 0 and (time() - current_time) > final_time:
+ break
  while cls.pause_simulation:
  pass
 
  @classmethod
- def startMobilityModelNoGraph(cls, mob, nodes):
+ def startMobilityModelNoGraph(cls, mob, nodes, current_time, final_time):
  """
  Useful when graph is not required
 
@@ -564,6 +568,8 @@ def startMobilityModelNoGraph(cls, mob, nodes):
  sleep(0.0001)
  node.getRange(intf=node.params['wlan'][0])
  sleep(0.5)
+ if final_time is not 0 and (time() - current_time) > final_time:
+ break
  while cls.pause_simulation:
  pass
 

mininet/wifiNet.py

@@ -31,6 +31,7 @@
 
 class mininetWiFi(object):
 
+ mobilityparam = dict()
  AC = ''
  alternativeModule = ''
  prop_model_name = ''
@@ -49,9 +50,7 @@ class mininetWiFi(object):
  plot = plot2d
  enable_wmediumd = False
  ppm_is_set = False
- init_time = 0
  wifiRadios = 0
- seed_ = 10
  MIN_X = 0
  MIN_Y = 0
  MIN_Z = 0
@@ -942,29 +941,21 @@ def checkDimension(cls, nodes):
  cls.DRAW = False
 
  @classmethod
- def start_mobility(cls, stations, aps, **kwargs):
+ def start_mobility(cls, **kwargs):
  "Starts Mobility"
- mobility_model = ''
  cls.isMobility = True
 
- if 'model' in kwargs:
- mobility_model = kwargs['model']
-
- if 'AC' in kwargs:
- cls.AC = kwargs['AC']
-
- if mobility_model != '' or cls.isVanet:
+ if 'model' in kwargs or cls.isVanet:
  stationaryNodes = []
- for sta in stations:
+ for sta in kwargs['stations']:
  if 'position' not in sta.params \
  or 'position' in sta.params \
  and sta.params['position'] == (-1,-1,-1):
  sta.isStationary = False
  stationaryNodes.append(sta)
  sta.params['position'] = 0, 0, 0
-
- params = cls.setMobilityParams(stations, aps,
- stationaryNodes, **kwargs)
+ kwargs['stationaryNodes'] = stationaryNodes
+ params = cls.setMobilityParams(**kwargs)
  if cls.nroads == 0:
  mobility.start(**params)
  else:
@@ -975,26 +966,24 @@ def stopMobility(cls, stations, aps, **kwargs):
  "Stops Mobility"
  cls.autoAssociation(stations, aps)
  kwargs['is3d'] = cls.is3d
- params = cls.setMobilityParams(stations, aps, **kwargs)
+ params = cls.setMobilityParams(**kwargs)
  mobility.stop(**params)
 
  @classmethod
- def setMobilityParams(cls, stations, aps, stationaryNodes=None, **kwargs):
+ def setMobilityParams(cls, **kwargs):
  "Set Mobility Parameters"
- mobilityparam = dict()
-
  if 'model' in kwargs:
- mobilityparam.setdefault('model', kwargs['model'])
- if 'time' in kwargs:
- mobilityparam.setdefault('final_time', kwargs['time'])
+ cls.mobilityparam.setdefault('model', kwargs['model'])
  if cls.nroads != 0:
- mobilityparam.setdefault('nroads', cls.nroads)
+ cls.mobilityparam.setdefault('nroads', cls.nroads)
  if 'repetitions' in kwargs:
- mobilityparam.setdefault('repetitions', kwargs['repetitions'])
+ cls.mobilityparam.setdefault('repetitions', kwargs['repetitions'])
  if 'plotNodes' in kwargs:
- mobilityparam.setdefault('plotNodes', kwargs['plotNodes'])
+ cls.mobilityparam.setdefault('plotNodes', kwargs['plotNodes'])
 
- if 'model' in kwargs or cls.isVanet:
+ if 'model' in kwargs:
+ stations = kwargs['stations']
+ aps = kwargs['aps']
  if 'min_x' in kwargs:
  if not cls.DRAW:
  cls.MIN_X = int(kwargs['min_x'])
@@ -1016,28 +1005,35 @@ def setMobilityParams(cls, stations, aps, stationaryNodes=None, **kwargs):
  for sta in stations:
  sta.max_y = int(kwargs['max_y'])
  if 'min_v' in kwargs:
- mobilityparam.setdefault('min_v', kwargs['min_v'])
+ cls.mobilityparam.setdefault('min_v', kwargs['min_v'])
  if 'max_v' in kwargs:
- mobilityparam.setdefault('max_v', kwargs['max_v'])
- if 'time' in kwargs:
- cls.init_time = kwargs['time']
-
- mobilityparam.setdefault('seed', cls.seed_)
- mobilityparam.setdefault('DRAW', cls.DRAW)
- mobilityparam.setdefault('stations', stations)
- mobilityparam.setdefault('aps', aps)
- mobilityparam.setdefault('connections', cls.connections)
- mobilityparam.setdefault('MIN_X', cls.MIN_X)
- mobilityparam.setdefault('MIN_Y', cls.MIN_Y)
- mobilityparam.setdefault('MIN_Z', cls.MIN_Z)
- mobilityparam.setdefault('MAX_X', cls.MAX_X)
- mobilityparam.setdefault('MAX_Y', cls.MAX_Y)
- mobilityparam.setdefault('MAX_Z', cls.MAX_Z)
- mobilityparam.setdefault('AC', cls.AC)
- mobilityparam.setdefault('init_time', cls.init_time)
- mobilityparam.setdefault('stationaryNodes', stationaryNodes)
- mobilityparam.setdefault('is3d', cls.is3d)
- return mobilityparam
+ cls.mobilityparam.setdefault('max_v', kwargs['max_v'])
+
+ if 'time' in kwargs:
+ if 'init_time' not in cls.mobilityparam:
+ cls.mobilityparam.setdefault('init_time', kwargs['time'])
+ else:
+ cls.mobilityparam.setdefault('final_time', kwargs['time'])
+ if 'seed' in kwargs:
+ cls.mobilityparam.setdefault('seed', kwargs['seed'])
+ if 'stations' in kwargs:
+ cls.mobilityparam.setdefault('stations', kwargs['stations'])
+ if 'aps' in kwargs:
+ cls.mobilityparam.setdefault('aps', kwargs['aps'])
+
+ cls.mobilityparam.setdefault('DRAW', cls.DRAW)
+ cls.mobilityparam.setdefault('connections', cls.connections)
+ cls.mobilityparam.setdefault('MIN_X', cls.MIN_X)
+ cls.mobilityparam.setdefault('MIN_Y', cls.MIN_Y)
+ cls.mobilityparam.setdefault('MIN_Z', cls.MIN_Z)
+ cls.mobilityparam.setdefault('MAX_X', cls.MAX_X)
+ cls.mobilityparam.setdefault('MAX_Y', cls.MAX_Y)
+ cls.mobilityparam.setdefault('MAX_Z', cls.MAX_Z)
+ cls.mobilityparam.setdefault('AC', cls.AC)
+ if 'stationaryNodes' in kwargs and kwargs['stationaryNodes'] is not []:
+ cls.mobilityparam.setdefault('stationaryNodes', kwargs['stationaryNodes'])
+ cls.mobilityparam.setdefault('is3d', cls.is3d)
+ return cls.mobilityparam
 
  @classmethod
  def useExternalProgram(cls, **params):
@@ -1242,10 +1238,12 @@ def getDistance(cls, src, dst):
 
  @classmethod
  def stop_simulation(self):
+ "Pause the simulation"
  mobility.pause_simulation = True
 
  @classmethod
  def start_simulation(self):
+ "Start the simulation"
  mobility.pause_simulation = False
 
  @classmethod