AraRAN Experiments

Experiment 1 - Transmitting, Receiving, and Visualizing Waveforms using UHD and GNURadio

Platform: Software Defined Radios.

Resources needed: 2 x USRP B210s

Short Description: Transmit and receive samples to a file using USRP Hardware Driver (UHD) and GNU Radio.

Detailed Description: The experiment makes use of UHD and Gnuradio to transmit signals from the base station, receive, visualize, and save the IQ samples to a file for analysis.

Follow the steps below to create leases and launch containers for this experiment:

Login to the portal ARA Portal with your username and password.
Create two reservations using the Project -> Reservations -> Leases tab from the dashboard:
1. gNB
  - Site: Sandbox
  - Resource Type: AraRAN
  - Device Type: Host
  - Device ID: 002
2. UE
  - Site: Sandbox
  - Resource Type: AraRAN
  - Device Type: Host
  - Device ID: 001
Create two containers on the respective nodes using the corresponding reservation IDs. For the containers, the Docker images can be used as follows:
1. gNB
  - Container Image: arawirelesshub/openairinterface5g:oai_gnb
  - CPU: 2
  - Memory: 5120
2. nrUE
  - Container Image: arawirelesshub/openairinterface5g:oai_nrue
  - CPU: 2
  - Memory: 5120
Note

Note that the above container images are equipped with USRP Hardware Driver (UHD).
Once the container is launched, associate a floating IP with the container using the Project -> Network -> Floating IPs tab.
The containers can be accessed via the console tab of the respective containers in the Project -> Containers tab from the dashboard or using SSH via the jumpbox server.

In the gNB container, run the following commands to transmit a sample waveform with specific frequency, sampling rate, bandwidth, and gain.

# cd /usr/local/lib/uhd/examples
# ./tx_waveforms --freq 3586.08e6 --rate 5e6 --gain 70

The output from the tx_waveforms is as follows:

Creating the usrp device with: ...
[INFO] [UHD] linux; GNU C++ version 7.5.0; Boost_106501; UHD_4.0.0.HEAD-0-g90ce6062
[INFO] [MPMD] Initializing 1 device(s) in parallel with args: mgmt_addr=192.168.20.2,type=n3xx,product=n320,serial=32584FD,claimed=False,addr=192.168.20.2
[INFO] [MPM.PeriphManager] init() called with device args `mgmt_addr=192.168.20.2,product=n320,clock_source=gpsdo,time_source=gpsdo'.
[INFO] [MPM.Rhodium-0] init() called with args `mgmt_addr=192.168.20.2,product=n320,clock_source=gpsdo,time_source=gpsdo'
[INFO] [MPM.Rhodium-1] init() called with args `mgmt_addr=192.168.20.2,product=n320,clock_source=gpsdo,time_source=gpsdo'
[INFO] [MPM.Rhodium-0] Re-initializing daughter board. This may take some time.
[INFO] [MPM.Rhodium-0] init() called with args `mgmt_addr=192.168.20.2,product=n320,clock_source=internal,time_source=internal,skip_rfic=None,master_clock_rate=245760000.0,ref_clk_freq=25000000.0'
[INFO] [MPM.Rhodium-0.init.LMK04828] LMK initialized and locked!
[INFO] [MPM.Rhodium-0.DAC37J82] DAC PLL Locked!
[INFO] [MPM.Rhodium-0.AD9695] ADC PLL Locked!
[INFO] [MPM.Rhodium-0.init] JESD204B Link Initialization & Training Complete
[INFO] [MPM.Rhodium-1] Re-initializing daughter board. This may take some time.
[INFO] [MPM.Rhodium-1] init() called with args `mgmt_addr=192.168.20.2,product=n320,clock_source=internal,time_source=internal,skip_rfic=None,master_clock_rate=245760000.0,ref_clk_freq=25000000.0'
[INFO] [MPM.Rhodium-1.init.LMK04828] LMK initialized and locked!
Using Device: Single USRP:
  Device: N300-Series Device
  Mboard 0: n320
  RX Channel: 0
    RX DSP: 0
    RX Dboard: A
    RX Subdev: Rhodium
  RX Channel: 1
    RX DSP: 1
    RX Dboard: B
    RX Subdev: Rhodium
  TX Channel: 0
    TX DSP: 0
    TX Dboard: A
    TX Subdev: Rhodium
  TX Channel: 1
    TX DSP: 1
    TX Dboard: B
    TX Subdev: Rhodium

Setting TX Rate: 1.000000 Msps...
Actual TX Rate: 0.999024 Msps...

Setting TX Freq: 3500.000000 MHz...
Setting TX LO Offset: 0.000000 MHz...
Actual TX Freq: 3500.000000 MHz...

Setting TX Gain: 0.000000 dB...
Actual TX Gain: 0.000000 dB...

[INFO] [MPM.Rhodium-1.DAC37J82] DAC PLL Locked!
[INFO] [MPM.Rhodium-1.AD9695] ADC PLL Locked!
[INFO] [MPM.Rhodium-1.init] JESD204B Link Initialization & Training Complete
[WARNING] [0/Radio#0] Attempting to set tick rate to 0. Skipping.
Setting device timestamp to 0...
Checking TX: all_los: locked ...
Press Ctrl + C to stop streaming...
^C
Done!

To visualize the DFT/FFT of the waveform generated in Step 6, run the following command in the nrUE container.
```
# cd /usr/local/lib/uhd/examples
# ./rx_ascii_art_dft --freq 3586.08e6 --rate 1e6 --gain 40 --ref-lvl -60
```
The terminal displays DFT/FFT as in the figure below when we run rx_ascii_art_dft

Note

We can change the properties of the waveform to suit our preference. Moreover, we can transmit an OFDM signal/waveform such as the one from the OAI nrsoftmodem.

Experiment 2: Monitoring AraMIMO Wireless Link Behavior using CLI

Platform: Skylark Wireless

Resources needed: Central Unit (CU), Distributed Unit (DU), Radio Unit (RU), and a Customer Premises Equipment (CPE)/User Equipment (UE)

Short Description: The experiment is designed to monitor wireless: link parameters of the AraMIMO deployment.

Detailed Description: AraMIMO consists of multiple CPEs connected to the Base Station (BS) which is a Skylark Wireless Faros V2 equipment. With this experiment, we can launch a container equipped with APIs to interact with Skylark CU and measure real-time link utilization and performance-related metrics on the Skylark platform. The figure below shows the detailed network and experient diagram.

Detailed Steps

Login to the portal portal.arawireless.org with your username and password. Please go through the Hello World example on how to login to portal, create a lease, launch a container, assign a floating IP address and accessing the container (or make sure you have already run that experiment successfully and are familiar with using the experiment portal).

NOTE

If you are a first time user, it is highly recommended to run the Hello World experiment first to get familiarized with the interface and portal.

Create a reservation using the Project -> Reservations -> Leases tab from the dashboard with the following attributes:
- Site: Data Center
- Resource Type: Compute Node
- Device Type: Compute Node
Launch a container equipped with APIs using the container image arawirelesshub/aramimo:v1.1
Associate floating IPs to the container using the Project -> Network -> Floating IPs tab.
The containers can be accessed via the Console tab of the respective containers in the Project -> Containers tab.
To SSH to the container using floating IP, ssh needs to enabled in the container. In Console, run the following command
```
# service ssh start
```
Set the password for root by typing the following command and then set the password
```
# passwd
```
Now the container can be accessed both from the dashboard Console or using ssh from the jumpbox server.
To ssh to the container, use the floating IP that is reserved for the container with root as username and password that is set in previous step.
In the container, Run the following command to launch the CLI.
```
# ara-sklk-cli
```
Run the following command to get the number of CPEs connected, SNR, and the average MCS. The information provides an idea about current system performance.
```
> get_ue_stats
```
For getting the Skylark UE ID and corresponding location, execute the following command.
```
> get_ue_locations
```

Type `help -v` to show all the commands that can be run to extract wireless link data such as SNR, throughput etc. Here are the list of commands that can be run.

get_center_freq      Return Center Frequency on all Radios
get_config           Return Current BS Configuration
get_connected_ues    Returns all the connected ues
get_csi_data         Returns csi data
get_ue_location      Returns the location of UEs
get_main_stats       Returns detailed statistics of the system
get_mcs              Print average MCS Index for UE's
get_phy_config       Print Phy Configuration Parameters
get_snr              Print Connected UE's SNR
get_ue_bus_rates     Print Bus Rates in Mbps
get_ue_data_rates    Print Data Rates in Mbps
get_ue_stats         Print Connected UE's Statistics
help                 List available commands with "help" or detailed help with "help cmd".
history              View, run, edit, and save previously entered commands.
quit                 Exit from the CLI

This container contains the AraMIMO Repo on Gitlab which contains other useful scripts along with documentation. The AraMIMO API is documented in the user manual.

Experiment 3: Capturing CSI Data using the AraMIMO deployment

Platform: Skylark Wireless

Resources needed: Central Unit (CU), Distributed Unit (DU), Radio Unit (RU), and a Customer Premises Equipment (CPE)/User Equipment (UE).

Short Description: The experiment is designed to capture raw CSI data using AraMIMO deployment.

Detailed Description: AraMIMO consists of multiple CPEs connected to the Base Station (BS), a Skylark Wireless Faros V2 equipment. Using this experiment, we launch a container equipped with APIs and AraMIMO Repo. For the network diagram, refer to Experiment 2: Monitoring AraMIMO Wireless Link Behavior using CLI above.

Detailed Steps

Follow the steps of Experiment 2: Monitoring AraMIMO Wireless Link Behavior using CLI up to Step 8 until the container is launched and the user has SSH access to the container.
Go to the root home directory.
```
# cd
```
Go to the aramimo directory.
```
# cd aramimo
```
The aramimo directory has multiple scripts to collect the measurement data. Run the csi script to start capturing the CSI data.
```
# ./csi_capture_script.py <time in seconds>
```
NOTE

The time can not be greater than 100 seconds. Each frame is 10ms, so 100s would capture CSI data of 10,000 frames.
As an example, enter the time as 10 seconds and execute the script. The script connects to the Skylark CU and start collecting the data.
Once the CSI capture is complete, the data will be saved to the /home/root/csi_data directory. The files can be saved locally to user’s computer via jumpbox for analysis. This script captures 3 files, i.e., csi.h5, csi_info.json, and hardware.json. The file csi.h5 contains the actual CSI data while the other two files contain system-related data such as data rates, SNR, and system parameters.
To save the files to local PC, first copy it over to the jumpbox server using scp. On the jumpbox server run the command.
```
# scp -r root@<floating_ip_of_container>:/home/root/csi_data ~/
```
The data from jumbox server can be copied to you local computer using the user’s ssh-key (assuming the data is saved user’s home directory on jumpbox server).
```
# scp -i <path_to_user_private_key> -r <username>@jbox.arawireless.org:~/csi_data .
```
The whole csi_data folder will be copied to the current directory of your host computer where the above command is run.

Experiment 4: Spectrum Sensing

Platform: Software Defined Radios USRP B210

Resources needed: User equipment with USRP B210.

Short Description: Collect the IQ samples for analyzing which spectrum bands are occupied in the span of interest.

Detailed Description: The experiment makes use of USRP Hardware Driver (UHD) and a Python script to compute the spectrum occupancy at regular intervals. The script logs the frequency components in a .csv file which can be copied by the users for analysis and visualization.

Follow the steps below to create leases and launch containers for this experiment:

Login to the ARA portal.
Create a reservation using the Project -> Reservations -> Leases tab from the dashboard using the following attributes:
- Site: CurtissFarm or Ames
- Resource Type: AraRAN
- Device Type: User Equipment
Launch a container on the reserved node using the corresponding reservation IDs as described in the Hello World experiment. For the container, use the following Docker image:
- Container Image: arawirelesshub/ara-sensing:v1
Note that the container is equipped with UHD and other required dependencies.
[Optional step if the user wants to access the container via SSH] Once the container is launched, associate a floating IP with the container using the Project -> Network -> Floating IPs tab.
The containers can be accessed via the console tab of the respective containers in the Project -> Containers tab from the dashboard or using ssh via the jumpbox server.
In the container, run the following commands to start the experiment
```
# cd /root
# python3 sensing-experiment.py
```
The command starts the experiment and logs the spectrum occupancy information in different files in the same folder. The users can copy the files to their computer and plot using a Python script or MATLAB and check the occupied spectrum bands between 3400 and 3600 MHz at that location.

Experiment 5: End-to-End 5G Standalone OpenAirInterface5g Experiment Using USRPs in Sandbox

Platform: Universal Software Radio Peripheral (USRP)

Resources needed: Two USRP B210s and a general purpose host computer

Short Description: The experiment demonstrates a basic end-to-end 5G network using OpenAirInterface5g and USRPs. The setup includes an OpenAirInterface (OAI) gNB and nrUE. The network uses a single core network provided by ARA for this setup.

Detailed Description: This experiment features a 5G network deployment using containerized 5G software components of OpenAirInterface5g, i.e., a containerized gNB, a containerized UE, and a containerized core network deployed in Intel x86 servers. Both gNB and nrUE containers run on general purpose Intel x86 servers which are connected to USRP B210 SDR via a USB 3.0 cable. The gNB is connected to the core network via a high-speed Ethernet link. The following figure shows the 5G network created from the experiment.

Detailed Steps for the Experiment

Login to ARA portal with your credentials.
Create two reservations using the Project -> Reservations -> Leases tab from the dashboard.
1. gNB
  - Site: Sandbox
  - Resource Type: AraRAN
  - Device Type: Host
  - Device ID: 002
2. UE
  - Site: Sandbox
  - Resource Type: AraRAN
  - Device Type: Host
  - Device ID: 001
Create the following two containers on the respective nodes using the corresponding reservation IDs. For the containers, the Docker images can be used as follows:
1. gNB
  - Container Image: arawirelesshub/openairinterface5g:oai_gnb
  - CPU: 2
  - Memory: 5120
2. nrUE
  - Container Image: arawirelesshub/openairinterface5g:oai_nrue
  - CPU: 2
  - Memory: 5120
Once the container is launched, associate a floating IPs with the containers using the Project -> Network -> Floating IPs tab.
The containers can be accessed via the console tab of the respective containers in the Project -> Containers tab from the dashboard or using ssh via the jumpbox server.
In both containers, run the following command to check the radios connected to the host.
```
# uhd_find_devices
```
The output of the above command should look like the following image.
In order to open and edit the configuration file for the gNB to suit the specifications of our experiment, do the following
```
# nano ~/openairinterface5g/targets/PROJECTS/GENERIC-NR-5GC/CONF/gnb.sa.band78.fr1.106PRB.usrpb210.conf
```
To make the gNB connected to our core network, we need to attach the gNB to the AMF of the core network. Follow Step 8 to open the gNB configuration file to make the necessary changes as seen in the figure below. For communicating the IP address, run ifconfig command and obtain the IP address assigned to eth0 interface of the container. Note that in the following image, we assume the IP address as 10.0.4.44.

In the gNB container, run the OAI gNB using the following commands.

# cd ~/openairinterface5g
# source oaienv
# cd cmake_targets/ran_build/build
# ./nr-softmodem -O ../../../targets/PROJECTS/GENERIC-NR-5GC/CONF/gnb.sa.band78.fr1.106PRB.usrpb210.conf --gNBs.[0].min_rxtxtime 6 --sa -E --continuous-tx

An important parameter that users want to change is the center frequency. Even though it is advisable to keep it default, the center frequency can be modified using the following two parameters.
1. absoluteFrequencySSB
2. dl_absoluteFrequencyPointA
The parameters above take NR ARFCN values for the specific center frequency. You can use the online 5G NR ARFCN Calculator to get the absoluteFrequencySSB in case if you are not familiar with the low-level calculation. To obtain the corresponding dl_absoluteFrequencyPointA, subtract 1272 from the absoluteFrequencySSB value.
In the UE container, run the OAI nrUE using the following commands in the UE container.
```
# cd ~/openairinterface5g
# source oaienv
# cd cmake_targets/ran_build/build
# ./nr-uesoftmodem -r 106 --numerology 1 --band 78 -C 3604800000 --ue-fo-compensation --sa -E --ue-txgain 0 --usrp-args "serial=8000232"
```
Console Traces

On establishing a successful connection, the commands provide the following output.

gNB Console Trace

nrUE Console Trace
Execute a Ping Test: The core network UPF assigns an IP address on the nrUE container. On the nrUE container, run the following command to ping the core network to ensure stable connection
```
# ping 10.189.16.35 -t -S <oai_tun_ue IP address>
```

Troubleshooting Hints

Permission Denied issue in Step 7: Stop the container and restart the container at least once to successfully find the USRP device(s) attached.
Crash/Core Dump in the nr-softmodem command: It may happen to crash the gNB when you first run the OAI nr-softmodem command. In such cases, running the command may resolve the issue.

Experiment 6: Outdoor Over-The-Air (OTA) Openairinterface 5G SA Experiment.

Platform: Openairinterface5g and Universal Software Radio Peripherals

Resources used: NI N320 (BS), N320 host computer, USRP B210, B210 host computer, power amplifiers, Commscope SS-65M-R2 Sector BS Antenna, and Laird OC69421 UE Antenna

Description: This experiment features a 5G network deployment using containerized 5G software components of OpenAirInterface5g, i.e., a containerized gNB, a containerized nrUE, and a containerized core network deployed in Intel x86 servers. The core network deployed in the data center and connects to the base station via long distance fiber backhaul connection. The following figure shows the 5G network created from the experiment.

Detailed Steps for the Experiment

Login to ARA portal with your credentials.
Create two reservations using the Project -> Reservations -> Leases tab from the dashboard.
1. gNB
  - Site: Curtiss Farm
  - Resource Type: AraRAN
  - Device Type: Base Station
  - Device ID: 001
2. UE
  - Site: Curtiss Farm
  - Resource Type: AraRAN
  - Device Type: User Equipment
  - Device ID: 001
Create the following two containers on the respective nodes using the corresponding reservation IDs. For the containers, the Docker images can be used as follows:
1. gNB
  - Container Image: arawirelesshub/openairinterface5g:oai_gnb_outdoor
  - CPU: 6
  - Memory: 8192
2. nrUE
  - Container Image: arawirelesshub/openairinterface5g:oai_nrue_outdoor
  - CPU: 4
  - Memory: 5120
Once the container is launched, associate floating IPs with the containers using the Project -> Network -> Floating IPs tab.
The containers can be accessed via the console tab of the respective containers in the Project -> Containers tab from the dashboard or using ssh via the jumpbox server.
In both containers, run the following command to check the radios connected to the host. In case the command cannot find SDR, refer the instructions in Troubleshooting Hints.
```
# uhd_find_devices
```
The output of the above command should look like the following image.
In order to connect gNB to the core network, we need to provide the container’s IP address and interface in the gNB configuration file. For finding the IP address of the container, run the following command.:
```
# ifconfig
```
Note down the IP address of the interface eth2.
Edit the configuration file to provide the Ethernet interface and IP address of the container.

Open the configuration file.
```
# nano ~/openairinterface5g/targets/PROJECTS/GENERIC-NR-5GC/CONF/gnb.sa.band78.fr1.106PRB.usrpb210.conf
```
To make gNB connected to our core network, we need to attach the gNB to the AMF of the core network. Edit the lines as shown in the figure below. Note that in the following image, we assume the IP address of the interface eth2 as 192.168.70.113.

Once the modification is complete, save and exit the nano editor.
Add a route to the core network from the gNB container with the following command.
```
# ip route add 192.168.70.128/26 via 192.168.70.126 dev eth2
```

Running the Base Station: In the gNB container, run the OAI gNB using the following commands. In case of any error, refer Troubleshooting Hints.

# cd ~/openairinterface5g
# source oaienv
# cd cmake_targets/ran_build/build
# ./nr-softmodem -O ../../../targets/PROJECTS/GENERIC-NR-5GC/CONF/gnb.sa.band78.fr1.106PRB.usrpb210.conf --gNBs.[0].min_rxtxtime 6 --sa --usrp-tx-thread-config 1

An important parameter that users want to change is the center frequency. Even though it is advisable to keep it default, the center frequency can be modified using the following two parameters in the above-mentioned configuration file.
1. absoluteFrequencySSB
2. dl_absoluteFrequencyPointA
The parameters above take NR ARFCN values for the specific center frequency. You can use the online 5G NR ARFCN Calculator to get the absoluteFrequencySSB in case if you are not familiar with the low-level calculation. To obtain the corresponding dl_absoluteFrequencyPointA, subtract 1272 from the absoluteFrequencySSB value.
Starting nrUE: In the UE container, run the OAI nrUE using the following commands. In case of error, refer Troubleshooting Hints.
```
# cd ~/openairinterface5g
# source oaienv
# cd cmake_targets/ran_build/build
# ./nr-uesoftmodem -O ../../../targets/PROJECTS/GENERIC-NR-5GC/CONF/ue.conf -r 106 --numerology 1 --band 78 -C 3604800000 --ue-fo-compensation --sa -E --ue-txgain 0 --nokrnmod 1
```
Console Traces

On establishing a successful connection, the commands provide the following output.

gNB Console Trace

nrUE Console Trace

Note

When the connection is established, we can observe a new interface oaitun_ue1 with an IP address assigned by the SMF of the core network. In order to find the IP address, run the command ifconfig in the nrUE container.

For this experiment, we assume that the IP address assigned to oaitun_ue1 as 12.1.1.2, which is used in the commands in the subsequent steps. Note that this IP will change anytime the UE is connected to the core network.

Note

ARA provides a dedicated core network for experimenters and is deployed in the data center. The oai-ext-dn container of the core network is reachable with the IP address 192.168.70.135. In addition, we run an iperf server on the core network for experimenters to test the end-to-end throughput.
Ping test to the Core Network: On the nrUE container, run the following command to ping the core network to ensure stable connection.
```
# ping -I 12.1.1.2 192.168.70.135
```
End-to-end throughput test: Run the iperf client to find the throughput toward the core network.
```
# iperf -c 192.168.70.135 -u -i 1 -B 12.1.1.2
```

Troubleshooting Hints

Permission Denied issue in Step 6: Stop the container and restart the container at least once to successfully find the USRP device(s) attached.
Crash/Core Dump in the nr-softmodem command: It may happen to crash the gNB when you first run the OAI nr-softmodem command. In such cases, running the command again and again may resolve the issue.