~comnets/openwns-systemtest-wimac/systemtest-wimac--main--1.0

import openwns

from openwns.pyconfig import Frozen

import openwns.evaluation.default

import scenarios

import scenarios.builders

import scenarios.placer

import scenarios.antenna

import ip

import ip.BackboneHelpers

import wimac.support.nodecreators

import wimac.support.helper

import wimac.evaluation.default

import wimac.support.PostProcessor as PostProcessor

from wimac.support.WiMACParameters import ParametersOFDM, ParametersMAC

import random

random.seed(7)

# Global station id generator

def stationID():

    id = 1

    while (True):

        yield id

        id += 1

stationIDs = stationID()

associations = {}

####################################################

###  Distinguished Simulation Settings             #

####################################################

class Config(Frozen):

    # Set basic WiMAX Parameters

    parametersPhy         = ParametersOFDM

    parametersMAC         = ParametersMAC

    parametersPhy.slotDuration = 3.0 *  parametersPhy.symbolDuration

    numberOfTimeSlots = 100

    packetSize = 86.0

    trafficUL = 5E5 # bit/s per station

    trafficDL = 5E5 # bit/s per station

    noIPHeader = True #Set to true to set IP header to 0

    probeWindowSize = 0.01 # Probe per frame

    scheduler = "RoundRobin" # "PropFair"

    settlingTime = 0.0

# General Setup

WNS = openwns.Simulator(simulationModel = openwns.node.NodeSimulationModel())

openwns.setSimulator(WNS)

WNS.maxSimTime = 0.07999 # seconds

WNS.masterLogger.backtrace.enabled = False

WNS.masterLogger.enabled = True

WNS.outputStrategy = openwns.simulator.OutputStrategy.DELETE

WNS.statusWriteInterval = 30 # in seconds

WNS.probesWriteInterval = 300 # in seconds

# Pass WiMAX Phy parameters to wimac::parameter::PHY singleton

WNS.modules.wimac.parametersPHY = Config.parametersPhy

WNS.modules.rise.debug.antennas = True                

# Create and place the nodes:

# One BS (25m omnidirectional antenna height) with two nodes, one near, one far

bsPlacer = scenarios.placer.HexagonalPlacer(numberOfCircles = 0, interSiteDistance = 100.0, rotate=0.0)

uePlacer = scenarios.placer.LinearPlacer(numberOfNodes = 2, positionsList = [10, 4000])

bsAntenna = scenarios.antenna.IsotropicAntennaCreator([0.0, 0.0, 5.0])

bsCreator = wimac.support.nodecreators.WiMAXBSCreator(stationIDs, Config)

ueCreator = wimac.support.nodecreators.WiMAXUECreator(stationIDs, Config)

channelmodelcreator = wimac.support.helper.TestChannelModelCreator()

scenarios.builders.CreatorPlacerBuilder(bsCreator, bsPlacer, bsAntenna, ueCreator, uePlacer, channelmodelcreator)

wimac.support.helper.setupPhy(WNS, Config, "LoS_Test")

# Set the scheduler

wimac.support.helper.setupScheduler(WNS, Config.scheduler)

# Set IP Header to 0 (else it is 20 byte)

if Config.noIPHeader:

    wimac.support.helper.disableIPHeader(WNS)

# Always create uplink traffic, if traffic UL is 0 we sent exacly 

# one packet for initialization

wimac.support.helper.createULPoissonTraffic(WNS, Config.trafficUL, Config.packetSize)

# Only create downlink traffic if we have any

if Config.trafficDL > 0.0:

    wimac.support.helper.createDLPoissonTraffic(WNS, Config.trafficDL, Config.packetSize)

# Configure the window probes

wimac.support.helper.setL2ProbeWindowSize(WNS, Config.probeWindowSize)

utNodes = WNS.simulationModel.getNodesByProperty("Type", "UE")

bsNodes = WNS.simulationModel.getNodesByProperty("Type", "BS")

##################################################################################################

# Configure the scheduler to use the BypassQueue

for bs in bsNodes:

    # Use the Bypass Queue

    # DL Master

    bs.dll.dlscheduler.config.txScheduler.queue = wimac.Scheduler.BypassQueue()

    bs.dll.dlscheduler.config.txScheduler.alwaysAcceptIfQueueAccepts = True

    # Use the Simple Queue

    # UL Master

    bs.dll.ulscheduler.config.rxScheduler.queue = openwns.Scheduler.SimpleQueue()

    bs.dll.ulscheduler.config.rxScheduler.alwaysAcceptIfQueueAccepts = True        

    # Pop the Reassembly FU

    bs.dll.subFUN.connects.pop(0)

    bs.dll.group.bottom = "buffer"

    # We need PseudeBWRequests with the Bypass Queue

    bs.dll.ulscheduler.config.rxScheduler.pseudoGenerator = wimac.Scheduler.PseudoBWRequestGenerator(

                'connectionManager',

                'ulscheduler',

                _packetSize = Config.packetSize,

                _pduOverhead = Config.parametersMAC.pduOverhead)

    if Config.noIPHeader:

        bs.dll.ulscheduler.config.rxScheduler.pseudoGenerator.pduOverhead -= 160

for ss in utNodes:

    # Use the Bypass Queue

    # UL Slave

    ss.dll.ulscheduler.config.txScheduler.queue = wimac.Scheduler.BypassQueue()

    ss.dll.ulscheduler.config.txScheduler.alwaysAcceptIfQueueAccepts = True

    # Pop the Reassembly FU

    ss.dll.subFUN.connects.pop(0)

    ss.dll.group.bottom = "buffer"

##################################################################################################

# DHCP, ARP, DNS for IP

ip.BackboneHelpers.createIPInfrastructure(WNS, "WIMAXRAN")

# Probe configuration

loggingStationIDs = []

for node in utNodes + bsNodes:    

    loggingStationIDs.append(node.dll.stationID)

wimac.evaluation.default.installDebugEvaluation(WNS, loggingStationIDs, Config.settlingTime, "Moments")

#wimac.evaluation.default.installOverFrameOffsetEvaluation(WNS, 

#                                                          Config.parametersPhy.symbolsFrame, 

#                                                          [1], 

#                                                          loggingStationIDs)

# Not present with BypassQueue

WNS.environment.probeBusRegistry.removeMeasurementSource("wimac.schedulerQueue.delay")

openwns.evaluation.default.installEvaluation(WNS)