wiki:Tutorials/g0WmLTE/Tutorial1

Version 5 (modified by seskar, 8 years ago) ( diff )

WiMAX "Hello World" Tutorial

Table of Contents

  1. WiMAX and LTE Tutorials
    1. Basic WiMax Operations
      1. Prerequisites
      2. Experiment: Image and Ping Nodes Over !WiMAX Interface
      3. About the Base Station
      4. Interacting with the Base Station
      5. Restoring the Base Station to Defaults
      6. Loading a Default Image
      7. Manually Confirming Settings
      8. Connect to the WiMAX Network
      9. Assign an IP Address
      10. Repeat for Other Nodes
      11. Recommended Settings for IP Addresses
      12. Testing Connection
      13. Troubleshooting Connectivity Problems
    1. WiMAX "Hello World" Tutorial
      1. Experimental Scenario
      2. Experiment Description
        1. Configuring WiMAX inteface
        2. Assigning the WiMAX IP Address
        3. Ping Application
        4. Experiment Code
    1. OMF Based WiMAX Experiment
      1. Prerequisites
      2. About This Experiment
      3. The Code
        1. Background Information
      4. Dissecting the Experiment
      5. Launch Experiment
      6. Troubleshooting Runtime Problems
      7. Retrieving Results
      8. Final Observations
    1. Basic LTE Tutorial
      1. Objective
      2. Set up
        1. Turn on the Aisrpsan basestation
        2. Connect to the node
        3. Loading the driver
        4. Connecting to the device
        5. Managing the LTE connection
        6. Testing the connection
        7. Reconnecting the client
    1. OpenAirInterface LTE Tutorials
        1. Build and Execution Scripts
        2. Configuration Files
        3. OAI Tutorials
      1. Basic OAI Tutorial
        1. Objective
        2. Quickstart Option
          1. Prepare the nodes
          2. Execute the experiment
      1. OAI Remote Radio Head (RRH)
        1. Objective
        2. Basic Setup
        3. Modify Transport
        4. Generalizing
      1. OAI RRH on ORBIT with eNB Baseband Running on GENI
    1. AmariSoft LTE
      1. Managing the Amarisoft eNB
    1. OpenAirInterface 5G Tutorials
        1. Build and Execution Scripts
        2. Configuration Files
        3. OAI Tutorials
    1. LTE interoperability
      1. Nexus 5, Nexus 5x configuration notes
      2. Notes
      3. OAI eNB with Amarisoft EPC
        1. Set Up
        2. Sequencing
        3. Preliminary Results
      4. Amarisoft eNB and EPC
      5. OAI eNB and EPC

This tutorial presents a simple example of using WiMAX devices that are available in ORBIT. The tutorial assumes basic understanding of OMF. If you are not familiar with it, please read the short OMF System Overview to familiarize yourself with the testbed control framework.

Experimental Scenario

The experimental scenario is fairly simple: our goal is to measure RTT of basic WiMAX link (single hop). This will be achieved by processing the output of a simple ping command. The output of the ping command will be passed through a regular expression and the results stored in an sqlite database.

Experiment Description

The expirment has two phases: setup and collection. In the setup phase we prime the interfaces with the necessary layer 3 information. In the collection phase we run the ping command and process the results.

Configuring WiMAX inteface

We need to connect each node to the basestation. We will use wimaxcu userspace utility for that. This application definition will invoke the the wimaxcu utility on each node with the arguments necessary to authenticate to the base station.

defApplication('wimaxcu', 'wimaxcu') {|a|
   a.name = "wimaxcu" 
     a.version(0, 0, 1)
     a.path = "/usr/bin/wimaxcu" 
     a.defProperty('args', "Arguments for wimaxcu command", nil,  {:order => 1, 
:dynamic => false, :type => :string, :use_name => false

Assigning the WiMAX IP Address

We will use dhclient command on the node to assign the IP address to the WiMAX interface. The following code snippet is the dhclient command wrapper that is used for ip address assignment on each individual node.

defApplication('dhclient', 'dhclient') {|a|
   a.name = "dhclient" 
     a.version(0, 0, 1)
     a.path = "/sbin/dhclient -q" 
     a.defProperty('interface', "DHCP client interface name", nil,  {:order => 1
, :dynamic => false, :type => :string, :use_name => false

Ping Application

This application definition wraps code around the ping command running on an individual node. Unlike the dhclient application definition, we're interested in it's output. We've defined a few measurement metrics (pieces of data we're interested in). When we examine the results in the sqlite database produced from this experiment the field will be labeled with these metric names. This wrapper is based on the OML4R command wrapper library (it's included in a require statement).

defApplication('pingtest_app', 'pingtest') do |a|
  a.path = "/usr/bin/pingtest.rb"
  a.version(0, 0, 1)
  a.shortDescription = "Wrapper around Ping -c"
  a.description = <<TEXT
This is a wrapper around the ping command.
This application is using OML4R part of OML v2.3 or v2.4
TEXT
  a.defProperty('ip', 'Ip address to ping', 'i', 
                {:type => :string, :dynamic => false})

  # List the Measurement Points and associated metrics that are available 
  # for this application
  #
  a.defMeasurement('pingtest') do |m|
    m.defMetric('ip',:string)
    m.defMetric('time',:string)
    m.defMetric('x',:string)
    m.defMetric('y',:string)
  end
end

Experiment Code

The last phase of the experiment description requires a script that coordinates all the elements. This code snippet specifies the nodes involved in the experiment and declares the applications and parameters required to run them.

defGroup('tester', [1,1]) do |node|
  node.addApplication('wimaxcu') { |app|
    app.setProperty('args','connect network 51')
  }
  node.addApplication('dhclient') { |app|
    app.setProperty('interface',"wmx0")
  }
  node.addApplication("pingtest_app") { |a|
    a.setProperty('ip',"10.41.0.1")
    a.measure('pingtest')
  }
end

Now that all the setup is done the actual experiment code is pretty simple. It boots the nodes, waits for 10 seconds for them to warm up and then runs the ping/collection.

whenAllInstalled() {|node|
   info "Give machines some time to warm up" 
   wait 10
   allGroups.startApplications
   info "Colect measurements for 100 seconds" 
   wait 100
   info "Finish it." 
   Experiment.done
}

Attachments (1)

Download all attachments as: .zip

Note: See TracWiki for help on using the wiki.